[ { "path": ".gitattributes", "content": "# Auto detect text files and perform LF normalization\n* text=auto\n" }, { "path": ".gitignore", "content": "**/__pycache__\n**/build/\n*.egg-info/\n*.egg\n*.pyc\n.DS_Store\n.vscode/\noutput.log" }, { "path": "LICENSE", "content": "MIT License\n\nCopyright (c) 2023 \n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "README.md", "content": "\n\n
\n

\nEoH: Evolution of Heuristics \n

\n

\nA Platform of Evolutionary Computation (EC) + Large Language Model (LLM) for Efficient Automatic Algorithm Design \n

\n\n[Chinese Version 中文版本](./README_CN.md)\n\n[![Github][Github-image]][Github-url]\n[![License][License-image]][License-url]\n[![Releases][Releases-image]][Releases-url]\n[![Wiki][Wiki-image]][Wiki-url]\n\n\n[Github-image]: https://img.shields.io/badge/github-12100E.svg?style=flat-square\n[License-image]: https://img.shields.io/badge/License-MIT-orange?style=flat-square\n[Releases-image]: https://img.shields.io/badge/Release-Version_1.0-blue?style=flat-square\n[Installation-image]: https://img.shields.io/badge/Web_Demo-Version_1.0-blue?style=flat-square\n[Wiki-image]: https://img.shields.io/badge/Docs-参考文档-black?style=flat-square\n\n\n[Github-url]: https://github.com/FeiLiu36/EOH\n[License-url]: https://github.com/FeiLiu36/EOH/blob/main/LICENSE\n[Releases-url]: https://github.com/FeiLiu36/EOH/releases\n[Wiki-url]: https://github.com/FeiLiu36/EOH/tree/main/docs\n\n\n\n
\n
\n\n> [!Important]\n> This Rep will be maintained at a low frequency. Please visit our latest general-purpose Platform [LLM4AD](https://github.com/Optima-CityU/llm4ad)!\n> \n> LLM4AD has a modulized framework with diverse methods (EoH, FunSearch, etc) and tasks (Optimization, Machine learning, etc).\n\nA Platform for **Evolutionary Computation** + **Large Language Model** for automatic algorithm design.\n\n\"eoh\"\n\n\n---\n## News 🔥 \n+ 2025.6 🎉🎉 We're excited to share that **EoH** recently set a **New World Record in Circle Packing Problem**, achieving a score of 2.63594 for 26 circles ! [Results here](https://github.com/Optima-CityU/llm4ad/tree/main/example/circle_packing)\n+ 2024.10.30, Survey Paper [A Systematic Survey on Large Language Models for Algorithm Design](https://arxiv.org/pdf/2410.14716) has been uploaded to Arxiv ! 🎉\n+ 2024.5.31, [Evolve Cost-aware Acquisition Functions Using Large Language Models](https://arxiv.org/abs/2404.16906) has been accepted at **PPSN 2024 (Best Paper Nomination)** ! 🎉\n+ 2024.5.31, [Understanding the Importance of Evolutionary Search in Automated Heuristic Design with Large Language Models](https://arxiv.org/pdf/2407.10873) has been accepted at **PPSN 2024**! 🎉\n+ 2024.5.5, [L-AutoDA: Leveraging Large Language Models for Automated Decision-based Adversarial Attacks](https://arxiv.org/abs/2401.15335) has been accepted at **GECCO 2024**! 🎉\n+ 2024.5.2, [EoH (Evolution of Heuristics: Towards Efficient Automatic Algorithm Design using Large Language Model)](https://arxiv.org/abs/2401.02051) has been accepted at **ICML 2024 (Oral, Top 1.5%)**! 🎉\n\n---\n\n## Introduction 📖\n\n\n\nHeuristics are indispensable for tackling complex search and optimization problems. However, manual heuristic design is tedious and demands significant human intuition and experience. \n\nEOH introduces a novel paradigm that leverages the synergy between Large Language Models (LLMs) and Evolutionary Computation (EC) for Automatic Heuristic Design (AHD). The coevolution of thoughts and codes within an evolutionary framework offers superior AHD performance while mitigating computational expenses. \n\n\"eoh\"\n\n\n\n\nEOH designs very competetive algorithms/heuristics in minutes/hours. Notably, It surpasses FunSearch, identifying superior heuristics with significantly fewer computational budgets (i.e., queries to LLMs) on online bin packing problem.\n\nThe following Figure shows the Evolution of EOH on the online bin packing problem. We outline the key **thoughts** and the corresponding **code** **snippets** that have contributed to the best results during evolution. Additionally, we mark the prompt strategies that result in improvement. Finally, we present the optimal heuristic in the final population and compare it to the heuristics designed by humans and from FunSearch.\n\n\"eoh\"\n\n\n\nIf you find EoH helpful for your research or applied projects:\n\n```bibtex\n@inproceedings{fei2024eoh,\n title={Evolution of Heuristics: Towards Efficient Automatic Algorithm Design Using Large Language Model},\n author={Fei Liu, Xialiang Tong, Mingxuan Yuan, Xi Lin, Fu Luo, Zhenkun Wang, Zhichao Lu, Qingfu Zhang},\n booktitle={International Conference on Machine Learning (ICML)},\n year={2024},\n url={https://arxiv.org/abs/2401.02051}\n}\n```\n\nIf you are interested on LLM4Opt or EoH, you can:\n\n1) Contact us through email fliu36-c@my.cityu.edu.hk.\n2) Visit [a collection of references and research papers on LLM4Opt](https://github.com/FeiLiu36/LLM4Opt)\n3) Join our Group (coming soon)\n\nIf you encounter any difficulty using the code, you can contact us through the above or submit an [issue](https://github.com/FeiLiu36/EoH/issues)\n\n\n\n## Requirements\n\n- python >= 3.10\n- numba\n- numpy\n- joblib\n\n\n\n## EoH Example Usage 💻 \n\n#### Step 1: Install EoH\n\nWe suggest install and run EoH in [conda](https://conda.io/projects/conda/en/latest/index.html) env with python>=3.10\n\n```bash\ncd eoh\n\npip install .\n```\n\n#### Step 2: Try Example: \n\n**Setup your Endpoint and Key for remote LLM or Setup your local LLM before start !** \n\nFor example, set the llm_api_endpoint to \"api.deepseek.com\", set llm_api_key to \"your key\", and set llm_model to \"deepseek-chat\".\n\n```python\nfrom eoh import eoh\nfrom eoh.utils.getParas import Paras\n\n# Parameter initilization #\nparas = Paras() \n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = \"bp_online\", #['tsp_construct','bp_online']\n llm_api_endpoint = \"xxx\", # set your LLM endpoint\n llm_api_key = \"xxx\", # set your LLM key\n llm_model = \"gpt-3.5-turbo-1106\",\n ec_pop_size = 5, # number of samples in each population\n ec_n_pop = 5, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False)\n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()\n```\n\n\n\n###### Example 1: Constructive Algorithm for TSP\n\n```bash\ncd examples/tsp_construct\n\npython runEoH.py\n\n```\n**Evaluation**\n```bash\ncd examples/tsp_construct/evaluation\n\ncopy your heuristic to heuristic.py (Note that the function name/input/output must align with the evaluation block!!)\n\npython runEval.py\n```\n\n###### Example 2: Online Bin Packing \n(**Generate new best heuristic and Beat Funsearch in 30 minutes on your personal computer !** i7-10700 2.9Ghz, 32 GB)\n\n```bash\ncd examples/bp_online\n\npython runEoH.py\n```\n**Evaluation**\n```bash\ncd examples/bp_online/evaluation\n\ncopy your heuristic to heuristic.py (Note that the function name/input/output must align with the evaluation block!!)\n\npython runEval.py\n```\n\n###### Example 3: Use EoH solve your local problem \n\n```bash\ncd examples/user_XXX\n\npython runEoH.py\n```\n\n\n\n### More Examples using EoH Platform (Code & Paper)\n\n\n| Area | Problem | Paper | Code |\n|-------------------------|----------------------------------------|---------------------------------|---------------------------------------------------------------|\n| Combinatorial Optimization | Online Bin Packing, greedy heuristic | [paper] | [code](https://github.com/FeiLiu36/EoH/tree/main/examples/user_bp_online) |\n| | TSP, construct heuristic | [paper] | [code](https://github.com/FeiLiu36/EoH/tree/main/examples/tsp_construct) |\n| | TSP, guided local search | [paper] | [code](https://github.com/FeiLiu36/EoH/tree/main/examples/user_tsp_gls) |\n| | Flow Shop Scheduling Problem (FSSP), guided local search | [paper] | [code](https://github.com/FeiLiu36/EoH/tree/main/examples/user_fssp_gls) |\n| Machine Learning | Attack | [paper](https://arxiv.org/abs/2401.15335) | [code](https://github.com/pgg3/L-AutoDA) |\n| Bayesian Optimization | Cost-aware Acquisition Function Design | [paper](https://arxiv.org/abs/2404.16906) | [code](https://github.com/FeiLiu36/EoH/tree/main/examples/user_bo_caf) |\n| Mathematics | Admissible sets | | |\n| Physics | Computational fluid dynamics | | | \n\n## Use EoH in Your Application\n\nA Step-by-step guide is provided in [here](./docs/QuickGuide.md) (coming soon)\n\n\n\n## LLMs \n\n1) Remote LLM + API (e.g., GPT3.5, Deepseek, Gemini Pro) (**Recommended !**):\n + OpenAI API.\n + [Deepseek API](https://platform.deepseek.com/)\n + Other APIs: \n + https://yukonnet.site/\n + https://github.com/chatanywhere/GPT_API_free\n + https://www.api2d.com/\n2) Local LLM Deployment + API (e.g., Llamacode, instruct Llama, gemma, deepseek, ...):\n + Step 1: Download Huggingface Model, for example, download gemma-2b-it (git clone https://huggingface.co/google/gemma-2b-it)\n + Step 2: \n + cd llm_server\n + python gemma_instruct_server.py\n + Step 3: Copy your url generated by running your server to request.py ( For example, set url='http://127.0.0.1:11012/completions') to test your server deployment. \n + Step 4: Copy your url generated by running your server to runEoH.py in your example. (For example, set url='http://127.0.0.1:11012/completions')\n + Step 5: Python runEoH.py\n3) Your Implementation: \n + If you want to use other LLM or if you want to use your own GPT API or local LLMs, please add your interface in ael/llm\n\n\n\n## Related Works on LLM4Opt\nWelcome to visit [a collection of references and research papers on LLM4Opt](https://github.com/FeiLiu36/LLM4Opt)\n\n\n## Contributors\n [Rui Zhang](https://github.com/RayZhhh) \n [Zhiyuan Yang](https://github.com/yzy1996) \n [Ping Guo](https://github.com/pgg3) \n [Shunyu Yao](https://github.com/ShunyuYao6)\n" }, { "path": "README_CN.md", "content": "\n\n
\n

\nEoH: Evolution of Heuristics \n

\n
\n进化计算+大模型 自动算法设计平台\n
\n\n [English Version 英文版本](./README.md)\n\n[![Github][Github-image]][Github-url]\n[![License][License-image]][License-url]\n[![Releases][Releases-image]][Releases-url]\n[![Wiki][Wiki-image]][Wiki-url]\n\n\n[Github-image]: https://img.shields.io/badge/github-12100E.svg?style=flat-square\n[License-image]: https://img.shields.io/badge/License-MIT-orange?style=flat-square\n[Releases-image]: https://img.shields.io/badge/Release-Version_1.0-blue?style=flat-square\n[Installation-image]: https://img.shields.io/badge/Web_Demo-Version_1.0-blue?style=flat-square\n[Wiki-image]: https://img.shields.io/badge/Docs-参考文档-black?style=flat-square\n\n\n[Github-url]: https://github.com/FeiLiu36/EOH\n[License-url]: https://github.com/FeiLiu36/EOH/blob/main/LICENSE\n[Releases-url]: https://github.com/FeiLiu36/EOH/releases\n[Wiki-url]: https://github.com/FeiLiu36/EOH/tree/main/docs\n\n\n\n
\n
\n\n\n\n**演变计算** + **大型语言模型**的平台，用于自动算法设计。\n\n\"eoh\"\n\n---\n## 新闻 🔥 \n\n+ 2024.5.5 [L-AutoDA: Leveraging Large Language Models for Automated Decision-based Adversarial Attacks](https://arxiv.org/abs/2401.15335) 已被 **GECCO 2024** 录用了! 🎉\n+ 2024.5.2 [EoH (Evolution of Heuristics: Towards Efficient Automatic Algorithm Design using Large Language Model)](https://arxiv.org/abs/2401.02051) 已被 **ICML 2024** 录用了！🎉\n\n---\n\n## 简介\n\n\n启发式算法在解决复杂的搜索和优化问题时是不可或缺的。然而，手动启发式设计是繁琐的，需要大量的人类直觉和经验。\n\nEOH引入了一种新的范式，利用大型语言模型（LLMs）和演变计算（EC）之间的协同作用进行自动启发式设计（AHD）。思维和代码在演变框架内的共同演化为卓越的AHD性能，同时降低了计算成本。\n\n\"eoh\"\n\nEOH在分钟/小时内设计出了非常有竞争力的算法/启发式方法。例如，在在线装箱问题上，EoH自动设计出新的最优启发式算法，优于人工设计算法和同期谷歌工作FunSearch。\n\n下图显示了在在线装箱问题上EOH的演变。我们概述了在演变过程中对最佳结果有所贡献的关键**思想**和相应的**代码**。此外，我们标记了导致改进的提示策略。最后，我们展示了最终种群中的最优启发式方法，并将其与人类设计的启发式方法和来自FunSearch的启发式方法进行了比较。\n\n\"ael\"\n\n\n\n如果您发现EoH对您的研究或应用项目有所帮助：\n\n```bibtex\n@inproceedings{fei2024eoh,\n title={Evolution of Heuristics: Towards Efficient Automatic Algorithm Design Using Large Language Model},\n author={Fei Liu, Xialiang Tong, Mingxuan Yuan, Xi Lin, Fu Luo, Zhenkun Wang, Zhichao Lu, Qingfu Zhang},\n booktitle={International Conference on Machine Learning (ICML)},\n year={2024},\n url={https://arxiv.org/abs/2401.02051}\n}\n```\n\n如果您对LLM4Opt或EoH感兴趣，您可以：\n\n+ 通过电子邮件fliu36-c@my.cityu.edu.hk与我们联系。\n+ 欢迎访问[大模型与优化参考文献和研究论文收藏](https://github.com/FeiLiu36/LLM4Opt)\n+ 加入我们的讨论组（即将推出）\n\n如果您在使用代码时遇到任何困难，请通过上述方式与我们联系或提交[问题]。\n\n## 系统要求\n+ python >= 3.10\n+ numba\n+ numpy\n+ joblib\n\n## EoH示例用法\n第1步：安装EoH\n我们建议在具有python>=3.10的[conda](https://conda.io/projects/conda/en/latest/index.html)环境中安装和运行EoH\n\n```bash\ncd eoh\n\npip install .\n```\n \n第2步：尝试示例：\n**在开始前设置您的端点和密钥以远程LLM或在启动之前设置您的本地LLM！**\n\n**例如： 把 llm_api_endpoint 设置为 \"api.deepseek.com\", 把 llm_api_key 设置为 \"your key\",把 llm_model 设置为 \"deepseek-chat\".**\n```python\nfrom eoh import eoh\nfrom eoh.utils.getParas import Paras\n\n# Parameter initilization #\nparas = Paras() \n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = \"bp_online\", #['tsp_construct','bp_online']\n llm_api_endpoint = \"xxx\", # set your LLM endpoint\n llm_api_key = \"xxx\", # set your LLM key\n llm_model = \"gpt-3.5-turbo-1106\",\n ec_pop_size = 5, # number of samples in each population\n ec_n_pop = 5, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False)\n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()\n```\n\n \n###### 示例1：旅行商问题的构造算法\n```bash\ncd examples/tsp_construct\n\npython runEoH.py\n```\n\n \n###### 示例2：在线装箱问题\n（在您的个人计算机上在30分钟内生成新的最佳启发式方法并击败Funsearch！ i7-10700 2.9Ghz, 32GB）\n\n```bash\ncd examples/bp_online\n\npython runEoH.py\n```\n \n###### 示例3：使用EoH解决您的本地问题\n```bash\ncd examples/local_problem\n\npython runEoH.py\n```\n \n### 使用EoH平台的更多示例（代码和论文）\n#### 组合优化\n+ 在线装箱问题 (BP)，贪婪启发式方法，代码, [论文]\n+ 旅行商问题 (TSP)，构造启发式方法，代码, [论文]\n+ 旅行商问题 (TSP)，引导式局部搜索，[代码], [论文]\n+ 流水车间调度问题（FSSP），引导式局部搜索，[代码], [论文]\n#### 机器学习\n+ 图像攻击，[代码], [论文](https://arxiv.org/abs/2401.15335)\n#### 贝叶斯优化\n+ 获取函数自动设计，[论文](https://arxiv.org/abs/2404.16906)\n#### 数学\n+ 可接受集合\n#### 物理学\n+ 计算流体动力学\n\n## 在您的应用程序中使用EoH\n提供了这里的逐步指南（即将推出）\n\n## 大模型设置\n1) 远程LLM + API（例如， GPT3.5, Deepseek, Gemini Pro) （推荐！）：\n+ OpenAI API。\n+ [Deepseek API](https://platform.deepseek.com/)\n+ 其他API：\n + https://yukonnet.site/ (Llama, Llamacode, Gemini Pro, 等)\n + https://github.com/chatanywhere/GPT_API_free\n + https://www.api2d.com/\n2) 本地LLM部署 + API（例如，Llamacode，instruct Llama，gemma，deepseek等）：\n+ 第1步：下载Huggingface模型，例如，下载gemma-2b-it（git clone https://huggingface.co/google/gemma-2b-it）\n+ 第2步： + cd llm_server + python gemma_instruct_server.py\n+ 第3步：将运行服务器生成的url复制到request.py（例如，将url='http://127.0.0.1:11012/completions'设置为测试您的服务器部署)。\n+ 第4步：将运行服务器生成的url复制到您的示例中的runAEL.py中（例如，将url='http://127.0.0.1:11012/completions'设置该项）。\n+ 第5步：Python runAEL.py\n3) 自己的实现：\n+ 如果您想使用其他LLM或自己的GPT API或本地LLMs，请在ael/llm中添加您的接口\n\n## 关于LLM4Opt的相关工作\n欢迎访问[大模型与优化参考文献和研究论文收藏](https://github.com/FeiLiu36/LLM4Opt)\n\n## 贡献者\n [Rui Zhang](https://github.com/RayZhhh) \n [Zhiyuan Yang](https://github.com/yzy1996) \n [Ping Guo](https://github.com/pgg3) \n [Shunyu Yao](https://github.com/ShunyuYao6)\n\n\n" }, { "path": "baseline/funsearch/.gitignore", "content": "ignore\n__pycache__\nlogs/\n.DS_Store\n.idea\n" }, { "path": "baseline/funsearch/LICENSE", "content": "\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n" }, { "path": "baseline/funsearch/README.md", "content": "# FunSearch Implementation\n\nThis repository implements the following publication:\n\n> Romera-Paredes, B. et al. [Mathematical discoveries from program search with large language models](https://www.nature.com/articles/s41586-023-06924-6). *Nature* (2023)\n\n## Installation and Requirements\n\nPlease note that **the Python version must be larger or equal to Python 3.9**, or the '*ast*' package used in the implementations will fail to work. \n\nYou can run FunSearch for online bin packing locally if enough GPU devices are available. Or you can try to use LLM interfaces to request responses online. \n\nPlease install the packages listed in `requirements.txt`.\n\n## Project Structure\n\nThere are some independent directories in this project:\n\n- `bin_packing` contains an example jupyter notebook for the bin packing task. [See here](#colab).\n- `implementation` contains an implementation of the evolutionary algorithm, code manipulation routines, and a single-threaded implementation of the FunSearch pipeline. \n- `llm-server` contains the implementations of an LLM server that gets the prompt by monitoring requests from FunSearch and response to the inference results to the FunSearch algorithm. \n\n## Files in `funsearch/implementation`\n\nThere are some files in `funsearch/implementation`. They are as follows:\n\n- `code_manipulatoin.py` provides functions to modify the code in the specification.\n- `config.py` includes configs of funsearch.\n- `evaluator.py` trims the sample results from LLM, and evaluates the sampled functions.\n- `evaluator_accelerate.py` accelerates the evaluation using the 'numba' library.\n- `funsearch.py` implements funsearch pipeline. \n- `profile.py` records the score of the sampled functions.\n- `programs_database.py` evolves the sampled functions.\n- `sampler.py` sends prompts to LLM and gets results.\n\n## Run FunSearch Demo on Colab\n\nThe jupyter notebook in `bin_packing/bin_packing_funsearch.ipynb` can be opened via [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/RayZhhh/funsearch/blob/main/bin_packing/bin_packing_funsearch.ipynb). Please note that do not run jupyter notebook locally, as the jupyter notebook backend does not support multiprocess running.\n\n## Run FunSearch Demo Locally\n\n### Parameters and Settings\n\nIf you want to adjust the following parameters, you should modify the code in `funsearch/implementation` manually. \n\n- `timeout_seconds` This parameter defines the maximum evaluation time for a single function. If the evaluation time exceeds this, the evaluation process will be killed. This strategy can prevent *while True* loop and reduce total evaluation costs but may discard potential outstanding functions. You can modify this in `implementation/evaluator.py/class Evaluator`.\n- `_reduce_score` This function does reduction to the score of a sampled function in some instances. The reduction is implemented as *mean* by default. You can modify it in `implementation/program_database.py`, where you can find a '_reduce_score' function.\n\n### Use Local LLM\n\n1. First, start the local LLM server.\n\n```shell\n# Suppose we are in funsearch directory (root dir of this project).\ncd llm-server\n# Start LLM server: python llm_server.py --port 8088 --path [model path] --d [GPU IDs]\npython llm_server.py --port 8088 --path /LLms/CodeLlama-34b --d 0 1 2 3 4 5\n```\n\n2. Then, start FunSearch.\n\n```shell\n# Run FunSearch\npython funsearch_bin_packing_local_llm.py\n```\n\nYou can see logs via *Tensorboard*. Please check the *log_dir* variable defined in `bin_packing_funsearch_my_template.py`, and start the Tensorboard using the following instructions:\n\n```shell\n# Suppose we are in funsearch directory (root directory of this project)\ncd logs\ntensorboard --logdir funsearch_local_llm\n```\n\n### Use LLM Interfaces\n\n1. Set the API's IP address according to your API provider. The code is in `funsearch_bin_packing_llm_api.py` line 33.\n\n```python\nconn = http.client.HTTPSConnection(\"api.chatanywhere.com.cn\")\n```\n\n2. Set the API key in request headers, the code lies in `funsearch_bin_packing_llm_api.py` line 44-48. You should replace `sk-ys...` with your API key.\n\n```python\nheaders = {\n 'Authorization': 'Bearer sk-ys02zx...(replace with your API key)...',\n 'User-Agent': 'Apifox/1.0.0 (https://apifox.com)',\n 'Content-Type': 'application/json'\n}\n```\n\n3. Start FunSearch.\n\n```shell\n# Run FunSearch\npython funsearch_bin_packing_llm_api.py\n```\n\nYou can see logs via *Tensorboard*. Please check the *log_dir* variable defined in `bin_packing_funsearch_my_template.py`, and start the Tensorboard using the following instructions:\n\n```shell\n# Suppose we are in funsearch directory (root directory of this project).\ncd logs\ntensorboard --logdir funsearch_llm_api\n```\n\n## Issue\n\nIf you encounter any difficulty using the code, please do not hesitate to submit an issue!\n" }, { "path": "baseline/funsearch/bin_packing/bin_packing_funsearch.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"source\": [\n \"# Run FunSearch on Bin Packing\\n\",\n \"Five steps:\\n\",\n \"1. Implement 'LLM' interface.\\n\",\n \"2. Implement a 'SandBox' interface.\\n\",\n \"3. Prepare a 'specification'.\\n\",\n \"4. Prepare a dataset.\\n\",\n \"5. Start FunSearch.\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"58ba1915fced4e72\"\n },\n {\n \"cell_type\": \"markdown\",\n \"source\": [\n \"## Preparation: download the project file from github. And update system path.\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"6a2d02b8e9c3ba67\"\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"outputs\": [],\n \"source\": [\n \"!git clone https://github.com/RayZhhh/funsearch.git\\n\",\n \"\\n\",\n \"import sys\\n\",\n \"\\n\",\n \"sys.path.append('/content/funsearch/')\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"22453e8153e0934c\"\n },\n {\n \"cell_type\": \"markdown\",\n \"source\": [\n \"## 1. Implement LLM interface\\n\",\n \"Set the API's IP address according to your API provider (See line 65 in the following code).\\n\",\n \"```python\\n\",\n \"conn = http.client.HTTPSConnection(\\\"api.chatanywhere.com.cn\\\")\\n\",\n \"```\\n\",\n \"You should prepare a 'key' for the LLM API. And fill them in the header (See line 76-80 in the following code).\\n\",\n \"```python\\n\",\n \"headers = {\\n\",\n \" 'Authorization': 'Bearer [put your key here, the key may start with \\\"sk-...\\\"]',\\n\",\n \" 'User-Agent': 'Apifox/1.0.0 (https://apifox.com)',\\n\",\n \" 'Content-Type': 'application/json'\\n\",\n \"}\\n\",\n \"```\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"fe47175708cc0a93\"\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"outputs\": [],\n \"source\": [\n \"import time\\n\",\n \"import json\\n\",\n \"import multiprocessing\\n\",\n \"from typing import Collection, Any\\n\",\n \"import http.client\\n\",\n \"from implementation import sampler\\n\",\n \"\\n\",\n \"\\n\",\n \"def _trim_preface_of_body(sample: str) -> str:\\n\",\n \" \\\"\\\"\\\"Trim the redundant descriptions/symbols/'def' declaration before the function body.\\n\",\n \" Please see my comments in sampler.LLM (in sampler.py).\\n\",\n \" Since the LLM used in this file is not a pure code completion LLM, this trim function is required.\\n\",\n \"\\n\",\n \" -Example sample (function & description generated by LLM):\\n\",\n \" -------------------------------------\\n\",\n \" This is the optimized function ...\\n\",\n \" def priority_v2(...) -> ...:\\n\",\n \" return ...\\n\",\n \" This function aims to ...\\n\",\n \" -------------------------------------\\n\",\n \" -This function removes the description above the function's signature, and the function's signature.\\n\",\n \" -The indent of the code is preserved.\\n\",\n \" -Return of this function:\\n\",\n \" -------------------------------------\\n\",\n \" return ...\\n\",\n \" This function aims to ...\\n\",\n \" -------------------------------------\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" lines = sample.splitlines()\\n\",\n \" func_body_lineno = 0\\n\",\n \" find_def_declaration = False\\n\",\n \" for lineno, line in enumerate(lines):\\n\",\n \" # find the first 'def' statement in the given code\\n\",\n \" if line[:3] == 'def':\\n\",\n \" func_body_lineno = lineno\\n\",\n \" find_def_declaration = True\\n\",\n \" break\\n\",\n \" if find_def_declaration:\\n\",\n \" code = ''\\n\",\n \" for line in lines[func_body_lineno + 1:]:\\n\",\n \" code += line + '\\\\n'\\n\",\n \" return code\\n\",\n \" return sample\\n\",\n \"\\n\",\n \"\\n\",\n \"class LLMAPI(sampler.LLM):\\n\",\n \" \\\"\\\"\\\"Language model that predicts continuation of provided source code.\\n\",\n \" \\\"\\\"\\\"\\n\",\n \"\\n\",\n \" def __init__(self, samples_per_prompt: int, trim=True):\\n\",\n \" super().__init__(samples_per_prompt)\\n\",\n \" additional_prompt = ('Complete a different and more complex Python function. '\\n\",\n \" 'Be creative and you can insert multiple if-else and for-loop in the code logic.'\\n\",\n \" 'Only output the Python code, no descriptions.')\\n\",\n \" self._additional_prompt = additional_prompt\\n\",\n \" self._trim = trim\\n\",\n \"\\n\",\n \" def draw_samples(self, prompt: str) -> Collection[str]:\\n\",\n \" \\\"\\\"\\\"Returns multiple predicted continuations of `prompt`.\\\"\\\"\\\"\\n\",\n \" return [self._draw_sample(prompt) for _ in range(self._samples_per_prompt)]\\n\",\n \"\\n\",\n \" def _draw_sample(self, content: str) -> str:\\n\",\n \" prompt = '\\\\n'.join([content, self._additional_prompt])\\n\",\n \" while True:\\n\",\n \" try:\\n\",\n \" conn = http.client.HTTPSConnection(\\\"api.chatanywhere.com.cn\\\")\\n\",\n \" payload = json.dumps({\\n\",\n \" \\\"max_tokens\\\": 512,\\n\",\n \" \\\"model\\\": \\\"gpt-3.5-turbo\\\",\\n\",\n \" \\\"messages\\\": [\\n\",\n \" {\\n\",\n \" \\\"role\\\": \\\"user\\\",\\n\",\n \" \\\"content\\\": prompt\\n\",\n \" }\\n\",\n \" ]\\n\",\n \" })\\n\",\n \" headers = {\\n\",\n \" 'Authorization': 'Bearer sk-ys02zx......(replace with your own)......',\\n\",\n \" 'User-Agent': 'Apifox/1.0.0 (https://apifox.com)',\\n\",\n \" 'Content-Type': 'application/json'\\n\",\n \" }\\n\",\n \" conn.request(\\\"POST\\\", \\\"/v1/chat/completions\\\", payload, headers)\\n\",\n \" res = conn.getresponse()\\n\",\n \" data = res.read().decode(\\\"utf-8\\\")\\n\",\n \" data = json.loads(data)\\n\",\n \" response = data['choices'][0]['message']['content']\\n\",\n \" # trim function\\n\",\n \" if self._trim:\\n\",\n \" response = _trim_preface_of_body(response)\\n\",\n \" return response\\n\",\n \" except Exception:\\n\",\n \" time.sleep(2)\\n\",\n \" continue\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"1999e45c9a568b08\"\n },\n {\n \"cell_type\": \"markdown\",\n \"source\": [\n \"## 2. Implement a 'SandBox' interface\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"d27817cdec2cedfc\"\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"outputs\": [],\n \"source\": [\n \"from implementation import evaluator\\n\",\n \"from implementation import evaluator_accelerate\\n\",\n \"\\n\",\n \"\\n\",\n \"class Sandbox(evaluator.Sandbox):\\n\",\n \" \\\"\\\"\\\"Sandbox for executing generated code. Implemented by RZ.\\n\",\n \"\\n\",\n \" RZ: Sandbox returns the 'score' of the program and:\\n\",\n \" 1) avoids the generated code to be harmful (accessing the internet, take up too much RAM).\\n\",\n \" 2) stops the execution of the code in time (avoid endless loop).\\n\",\n \" \\\"\\\"\\\"\\n\",\n \"\\n\",\n \" def __init__(self, verbose=False, numba_accelerate=True):\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" Args:\\n\",\n \" verbose : Print evaluate information.\\n\",\n \" numba_accelerate: Use numba to accelerate the evaluation. It should be noted that not all numpy functions\\n\",\n \" support numba acceleration, such as np.piecewise().\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" self._verbose = verbose\\n\",\n \" self._numba_accelerate = numba_accelerate\\n\",\n \"\\n\",\n \" def run(\\n\",\n \" self,\\n\",\n \" program: str,\\n\",\n \" function_to_run: str, # RZ: refers to the name of the function to run (e.g., 'evaluate')\\n\",\n \" function_to_evolve: str, # RZ: accelerate the code by decorating @numba.jit() on function_to_evolve.\\n\",\n \" inputs: Any, # refers to the dataset\\n\",\n \" test_input: str, # refers to the current instance\\n\",\n \" timeout_seconds: int,\\n\",\n \" **kwargs # RZ: add this\\n\",\n \" ) -> tuple[Any, bool]:\\n\",\n \" \\\"\\\"\\\"Returns `function_to_run(test_input)` and whether execution succeeded.\\n\",\n \"\\n\",\n \" RZ: If the generated code (generated by LLM) is executed successfully,\\n\",\n \" the output of this function is the score of a given program.\\n\",\n \" RZ: PLEASE NOTE THAT this SandBox is only designed for bin-packing problem.\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" dataset = inputs[test_input]\\n\",\n \" try:\\n\",\n \" result_queue = multiprocessing.Queue()\\n\",\n \" process = multiprocessing.Process(\\n\",\n \" target=self._compile_and_run_function,\\n\",\n \" args=(program, function_to_run, function_to_evolve, dataset, self._numba_accelerate, result_queue)\\n\",\n \" )\\n\",\n \" process.start()\\n\",\n \" process.join(timeout=timeout_seconds)\\n\",\n \" if process.is_alive():\\n\",\n \" # if the process is not finished in time, we consider the program illegal\\n\",\n \" process.terminate()\\n\",\n \" process.join()\\n\",\n \" results = None, False\\n\",\n \" else:\\n\",\n \" if not result_queue.empty():\\n\",\n \" results = result_queue.get_nowait()\\n\",\n \" else:\\n\",\n \" results = None, False\\n\",\n \"\\n\",\n \" return results\\n\",\n \" except:\\n\",\n \" return None, False\\n\",\n \"\\n\",\n \" def _compile_and_run_function(self, program, function_to_run, function_to_evolve, dataset, numba_accelerate,\\n\",\n \" result_queue):\\n\",\n \" try:\\n\",\n \" # optimize the code (decorate function_to_run with @numba.jit())\\n\",\n \" if numba_accelerate:\\n\",\n \" program = evaluator_accelerate.add_numba_decorator(\\n\",\n \" program=program,\\n\",\n \" function_to_evolve=function_to_evolve\\n\",\n \" )\\n\",\n \" # compile the program, and maps the global func/var/class name to its address\\n\",\n \" all_globals_namespace = {}\\n\",\n \" # execute the program, map func/var/class to global namespace\\n\",\n \" exec(program, all_globals_namespace)\\n\",\n \" # get the pointer of 'function_to_run'\\n\",\n \" function_to_run = all_globals_namespace[function_to_run]\\n\",\n \" # return the execution results\\n\",\n \" results = function_to_run(dataset)\\n\",\n \" # the results must be int or float\\n\",\n \" if not isinstance(results, (int, float)):\\n\",\n \" result_queue.put((None, False))\\n\",\n \" return\\n\",\n \" result_queue.put((results, True))\\n\",\n \" except Exception:\\n\",\n \" # if raise any exception, we assume the execution failed\\n\",\n \" result_queue.put((None, False))\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"3e3d88a87535b6b2\"\n },\n {\n \"cell_type\": \"markdown\",\n \"source\": [\n \"## 3. Prepare a 'specification'\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"ec3a05827354f9ae\"\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"outputs\": [],\n \"source\": [\n \"specification = r'''\\n\",\n \"import numpy as np\\n\",\n \"\\n\",\n \"\\n\",\n \"def get_valid_bin_indices(item: float, bins: np.ndarray) -> np.ndarray:\\n\",\n \" \\\"\\\"\\\"Returns indices of bins in which item can fit.\\\"\\\"\\\"\\n\",\n \" return np.nonzero((bins - item) >= 0)[0]\\n\",\n \"\\n\",\n \"\\n\",\n \"def online_binpack(\\n\",\n \" items: tuple[float, ...], bins: np.ndarray\\n\",\n \") -> tuple[list[list[float, ...], ...], np.ndarray]:\\n\",\n \" \\\"\\\"\\\"Performs online binpacking of `items` into `bins`.\\\"\\\"\\\"\\n\",\n \" # Track which items are added to each bin.\\n\",\n \" packing = [[] for _ in bins]\\n\",\n \" # Add items to bins.\\n\",\n \" for item in items:\\n\",\n \" # Extract bins that have sufficient space to fit item.\\n\",\n \" valid_bin_indices = get_valid_bin_indices(item, bins)\\n\",\n \" # Score each bin based on heuristic.\\n\",\n \" priorities = priority(item, bins[valid_bin_indices])\\n\",\n \" # Add item to bin with highest priority.\\n\",\n \" best_bin = valid_bin_indices[np.argmax(priorities)]\\n\",\n \" bins[best_bin] -= item\\n\",\n \" packing[best_bin].append(item)\\n\",\n \" # Remove unused bins from packing.\\n\",\n \" packing = [bin_items for bin_items in packing if bin_items]\\n\",\n \" return packing, bins\\n\",\n \"\\n\",\n \"\\n\",\n \"@funsearch.run\\n\",\n \"def evaluate(instances: dict) -> float:\\n\",\n \" \\\"\\\"\\\"Evaluate heuristic function on a set of online binpacking instances.\\\"\\\"\\\"\\n\",\n \" # List storing number of bins used for each instance.\\n\",\n \" num_bins = []\\n\",\n \" # Perform online binpacking for each instance.\\n\",\n \" for name in instances:\\n\",\n \" instance = instances[name]\\n\",\n \" capacity = instance['capacity']\\n\",\n \" items = instance['items']\\n\",\n \" # Create num_items bins so there will always be space for all items,\\n\",\n \" # regardless of packing order. Array has shape (num_items,).\\n\",\n \" bins = np.array([capacity for _ in range(instance['num_items'])])\\n\",\n \" # Pack items into bins and return remaining capacity in bins_packed, which\\n\",\n \" # has shape (num_items,).\\n\",\n \" _, bins_packed = online_binpack(items, bins)\\n\",\n \" # If remaining capacity in a bin is equal to initial capacity, then it is\\n\",\n \" # unused. Count number of used bins.\\n\",\n \" num_bins.append((bins_packed != capacity).sum())\\n\",\n \" # Score of heuristic function is negative of average number of bins used\\n\",\n \" # across instances (as we want to minimize number of bins).\\n\",\n \" return -np.mean(num_bins)\\n\",\n \"\\n\",\n \"\\n\",\n \"@funsearch.evolve\\n\",\n \"def priority(item: float, bins: np.ndarray) -> np.ndarray:\\n\",\n \" \\\"\\\"\\\"Returns priority with which we want to add item to each bin.\\n\",\n \"\\n\",\n \" Args:\\n\",\n \" item: Size of item to be added to the bin.\\n\",\n \" bins: Array of capacities for each bin.\\n\",\n \"\\n\",\n \" Return:\\n\",\n \" Array of same size as bins with priority score of each bin.\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" ratios = item / bins\\n\",\n \" log_ratios = np.log(ratios)\\n\",\n \" priorities = -log_ratios\\n\",\n \" return priorities\\n\",\n \"'''\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"2e2f875d128a693a\"\n },\n {\n \"cell_type\": \"markdown\",\n \"source\": [\n \"## 4. Prepare a dataset\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"391bfe61e1661e18\"\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"outputs\": [],\n \"source\": [\n \"import bin_packing_utils\\n\",\n \"\\n\",\n \"bin_packing_or3 = {'OR3': bin_packing_utils.datasets['OR3']}\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"fea85ccfc8c0ca6d\"\n },\n {\n \"cell_type\": \"markdown\",\n \"source\": [\n \"## 5. Start FunSearch\\n\",\n \"Please note that in jupyter notebook the following code will fail. This is because juypter does not support multiprocessing. Colab backend supports multiprocessing.\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"cb66651fb2764ce9\"\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"outputs\": [],\n \"source\": [\n \"from implementation import funsearch\\n\",\n \"from implementation import config\\n\",\n \"\\n\",\n \"# It should be noted that the if __name__ == '__main__' is required.\\n\",\n \"# Because the inner code uses multiprocess evaluation.\\n\",\n \"if __name__ == '__main__':\\n\",\n \" class_config = config.ClassConfig(llm_class=LLMAPI, sandbox_class=Sandbox)\\n\",\n \" config = config.Config(samples_per_prompt=4)\\n\",\n \" global_max_sample_num = 10 # if it is set to None, funsearch will execute an endless loop\\n\",\n \" funsearch.main(\\n\",\n \" specification=specification,\\n\",\n \" inputs=bin_packing_or3,\\n\",\n \" config=config,\\n\",\n \" max_sample_nums=global_max_sample_num,\\n\",\n \" class_config=class_config,\\n\",\n \" log_dir='../logs/funsearch_llm_api'\\n\",\n \" )\"\n ],\n \"metadata\": {\n \"collapsed\": false\n },\n \"id\": \"1e0ec0c796d09ca1\"\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 2\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython2\",\n \"version\": \"2.7.6\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 5\n}\n" }, { "path": "baseline/funsearch/bin_packing_utils.py", "content": "# @title\nfrom __future__ import annotations\nimport numpy as np\nfrom typing import Tuple\n\ndatasets = {}\n\n# Data from the OR3 benchmark, containing 20 bin packing instances each with 500 items.\ndatasets['OR3'] = {'u500_00': {'capacity': 150, 'num_items': 500,\n 'items': [42, 69, 67, 57, 93, 90, 38, 36, 45, 42, 33, 79, 27, 57, 44, 84, 86, 92, 46, 38,\n 85, 33, 82, 73, 49, 70, 59, 23, 57, 72, 74, 69, 33, 42, 28, 46, 30, 64, 29, 74,\n 41, 49, 55, 98, 80, 32, 25, 38, 82, 30, 35, 39, 57, 84, 62, 50, 55, 27, 30, 36,\n 20, 78, 47, 26, 45, 41, 58, 98, 91, 96, 73, 84, 37, 93, 91, 43, 73, 85, 81, 79,\n 71, 80, 76, 83, 41, 78, 70, 23, 42, 87, 43, 84, 60, 55, 49, 78, 73, 62, 36, 44,\n 94, 69, 32, 96, 70, 84, 58, 78, 25, 80, 58, 66, 83, 24, 98, 60, 42, 43, 43, 39,\n 97, 57, 81, 62, 75, 81, 23, 43, 50, 38, 60, 58, 70, 88, 36, 90, 37, 45, 45, 39,\n 44, 53, 70, 24, 82, 81, 47, 97, 35, 65, 74, 68, 49, 55, 52, 94, 95, 29, 99, 20,\n 22, 25, 49, 46, 98, 59, 98, 60, 23, 72, 33, 98, 80, 95, 78, 57, 67, 53, 47, 53,\n 36, 38, 92, 30, 80, 32, 97, 39, 80, 72, 55, 41, 60, 67, 53, 65, 95, 20, 66, 78,\n 98, 47, 100, 85, 53, 53, 67, 27, 22, 61, 43, 52, 76, 64, 61, 29, 30, 46, 79,\n 66, 27, 79, 98, 90, 22, 75, 57, 67, 36, 70, 99, 48, 43, 45, 71, 100, 88, 48,\n 27, 39, 38, 100, 60, 42, 20, 69, 24, 23, 92, 32, 84, 36, 65, 84, 34, 68, 64,\n 33, 69, 27, 47, 21, 85, 88, 59, 61, 50, 53, 37, 75, 64, 84, 74, 57, 83, 28, 31,\n 97, 61, 36, 46, 37, 96, 80, 53, 51, 68, 90, 64, 81, 66, 67, 80, 37, 92, 67, 64,\n 31, 94, 45, 80, 28, 76, 29, 64, 38, 48, 40, 29, 44, 81, 35, 51, 48, 67, 24, 46,\n 38, 76, 22, 30, 67, 45, 41, 29, 41, 79, 21, 25, 90, 62, 34, 73, 50, 79, 66, 59,\n 42, 90, 79, 70, 66, 80, 35, 62, 98, 97, 37, 32, 75, 91, 91, 48, 26, 23, 32,\n 100, 46, 29, 26, 29, 26, 83, 82, 92, 95, 87, 63, 57, 100, 63, 65, 81, 46, 42,\n 95, 90, 80, 53, 27, 84, 40, 22, 97, 20, 73, 63, 95, 46, 42, 47, 40, 26, 88, 49,\n 24, 92, 87, 68, 95, 34, 82, 84, 43, 54, 73, 66, 32, 62, 48, 99, 90, 86, 28, 25,\n 25, 89, 67, 96, 35, 33, 70, 40, 59, 32, 94, 34, 86, 35, 45, 25, 76, 80, 42, 91,\n 44, 91, 97, 60, 29, 45, 37, 61, 54, 78, 56, 74, 74, 45, 21, 96, 37, 75, 100,\n 58, 84, 85, 56, 54, 71, 52, 79, 43, 35, 27, 70, 31, 47, 35, 26, 30, 97, 90, 80,\n 58, 60, 73, 46, 71, 39, 42, 98, 27, 21, 71, 71, 78, 76, 57, 24, 91, 84, 35, 25,\n 77, 96, 97, 89, 30, 86]}, 'u500_01': {'capacity': 150, 'num_items': 500,\n 'items': [81, 39, 75, 66, 85, 36, 60, 56,\n 50, 75, 75, 37, 87, 95, 21, 99,\n 42, 57, 31, 37, 42, 40, 69, 91,\n 45, 97, 84, 90, 52, 43, 68, 53,\n 37, 65, 79, 73, 92, 87, 20, 20,\n 73, 42, 52, 20, 24, 76, 71, 72,\n 21, 21, 82, 92, 78, 87, 50, 41,\n 31, 73, 89, 59, 88, 40, 71, 69,\n 45, 57, 49, 68, 84, 32, 69, 77,\n 92, 98, 57, 39, 32, 23, 99, 91,\n 48, 21, 70, 43, 73, 69, 65, 57,\n 67, 28, 84, 42, 61, 92, 82, 34,\n 74, 55, 60, 69, 26, 25, 67, 77,\n 67, 79, 47, 84, 50, 21, 87, 83,\n 44, 88, 78, 53, 78, 37, 47, 52,\n 32, 88, 85, 82, 55, 41, 60, 66,\n 78, 72, 34, 64, 20, 60, 100,\n 62, 80, 34, 68, 38, 32, 32, 37,\n 82, 98, 90, 58, 97, 56, 34, 70,\n 39, 56, 69, 36, 20, 99, 84, 53,\n 27, 88, 53, 42, 45, 42, 31, 54,\n 60, 55, 27, 36, 31, 39, 91, 45,\n 97, 26, 80, 41, 56, 70, 97, 48,\n 87, 23, 32, 75, 100, 97, 51,\n 78, 78, 21, 72, 72, 79, 46, 30,\n 48, 27, 95, 48, 67, 58, 46, 92,\n 21, 82, 91, 40, 56, 24, 94, 44,\n 91, 92, 81, 24, 84, 44, 83, 37,\n 98, 85, 88, 95, 29, 35, 100,\n 55, 48, 27, 20, 66, 62, 52, 88,\n 59, 97, 91, 81, 81, 86, 48, 43,\n 60, 72, 88, 90, 48, 38, 60, 53,\n 55, 90, 48, 55, 57, 59, 25, 51,\n 22, 43, 31, 52, 89, 96, 58, 63,\n 27, 46, 43, 30, 44, 71, 66, 64,\n 28, 83, 88, 42, 92, 95, 36, 24,\n 62, 44, 82, 59, 31, 96, 44, 61,\n 78, 72, 62, 76, 65, 22, 41, 27,\n 85, 80, 72, 100, 29, 27, 43,\n 83, 32, 33, 53, 95, 99, 20, 23,\n 72, 50, 50, 27, 89, 53, 75, 81,\n 34, 27, 69, 48, 84, 37, 69, 54,\n 51, 49, 49, 54, 100, 55, 45,\n 83, 61, 96, 91, 37, 53, 76, 50,\n 66, 70, 87, 92, 35, 53, 95, 47,\n 56, 55, 86, 32, 99, 83, 88, 41,\n 63, 77, 60, 66, 53, 79, 81, 96,\n 34, 99, 47, 74, 87, 44, 77, 52,\n 99, 69, 64, 94, 38, 69, 61, 98,\n 40, 84, 89, 49, 64, 53, 41, 34,\n 85, 35, 55, 61, 68, 100, 75,\n 98, 36, 44, 57, 24, 60, 45, 48,\n 60, 94, 71, 70, 64, 62, 93, 20,\n 69, 37, 63, 61, 26, 54, 89, 46,\n 54, 50, 32, 71, 62, 40, 26, 59,\n 62, 27, 60, 50, 74, 34, 40, 70,\n 56, 23, 66, 57, 43, 45, 65, 25,\n 82, 82, 37, 66, 47, 44, 94, 23,\n 24, 51, 100, 22, 25, 51, 95,\n 58, 97, 30, 79, 23, 53, 80, 20,\n 65, 64, 21, 26, 100, 81, 98,\n 70, 85, 92, 97, 86, 71, 91, 29,\n 63, 34, 67, 23, 33, 89, 94, 47,\n 100, 37, 40, 58]},\n 'u500_02': {'capacity': 150, 'num_items': 500,\n 'items': [73, 39, 49, 79, 54, 57, 98, 69, 67, 49, 38, 34, 96, 27, 92, 82, 69, 45, 69, 20,\n 75, 97, 51, 70, 29, 91, 98, 77, 48, 45, 43, 61, 36, 82, 89, 94, 26, 35, 58, 58,\n 57, 46, 44, 91, 49, 52, 65, 42, 33, 60, 37, 57, 91, 52, 95, 84, 72, 75, 89, 81,\n 67, 74, 87, 60, 32, 76, 85, 59, 62, 39, 64, 52, 88, 45, 29, 88, 85, 54, 40, 57,\n 91, 55, 60, 37, 86, 21, 21, 43, 77, 75, 92, 33, 59, 74, 40, 36, 62, 21, 56, 38,\n 22, 45, 94, 68, 83, 86, 75, 21, 40, 44, 74, 52, 61, 95, 20, 79, 76, 32, 21, 91,\n 83, 39, 31, 81, 41, 90, 74, 100, 38, 33, 74, 40, 80, 39, 22, 46, 58, 65, 67,\n 37, 82, 64, 26, 80, 74, 20, 62, 82, 40, 28, 72, 45, 62, 72, 89, 31, 92, 63, 89,\n 33, 25, 54, 66, 100, 20, 90, 87, 48, 28, 46, 76, 50, 66, 30, 26, 23, 40, 70,\n 57, 92, 52, 54, 27, 58, 66, 65, 93, 83, 37, 62, 94, 29, 66, 98, 20, 66, 42, 52,\n 90, 22, 30, 34, 65, 81, 90, 44, 88, 51, 97, 79, 58, 46, 65, 40, 68, 64, 34, 59,\n 99, 82, 86, 88, 52, 76, 76, 50, 51, 92, 59, 22, 60, 69, 45, 66, 50, 62, 59, 90,\n 54, 55, 92, 23, 97, 73, 39, 88, 34, 92, 74, 90, 55, 28, 45, 71, 56, 45, 63, 26,\n 20, 34, 78, 26, 21, 99, 50, 52, 29, 52, 84, 78, 84, 89, 93, 83, 97, 35, 29, 80,\n 99, 86, 63, 100, 87, 54, 48, 72, 98, 43, 81, 96, 77, 92, 32, 66, 82, 52, 30,\n 52, 97, 56, 44, 67, 60, 79, 78, 90, 38, 99, 42, 97, 63, 39, 69, 67, 91, 38, 37,\n 51, 98, 30, 77, 78, 35, 33, 94, 36, 59, 85, 98, 80, 79, 68, 61, 27, 95, 83, 91,\n 90, 38, 93, 22, 35, 38, 100, 26, 35, 64, 40, 79, 49, 88, 41, 28, 62, 78, 65,\n 90, 35, 50, 62, 91, 57, 60, 50, 28, 77, 97, 35, 40, 21, 73, 30, 75, 50, 27, 58,\n 59, 94, 60, 55, 89, 84, 91, 65, 99, 89, 83, 47, 52, 24, 66, 98, 51, 21, 23, 78,\n 41, 99, 52, 36, 69, 70, 91, 54, 38, 98, 57, 64, 76, 61, 31, 27, 23, 22, 61, 65,\n 35, 37, 75, 54, 97, 45, 78, 22, 79, 76, 81, 78, 41, 59, 28, 58, 90, 78, 57, 63,\n 24, 27, 79, 67, 88, 49, 57, 78, 87, 66, 91, 37, 51, 49, 84, 32, 62, 36, 52, 72,\n 59, 77, 54, 46, 57, 69, 81, 80, 99, 87, 33, 45, 43, 66, 28, 30, 54, 23, 79, 69,\n 56, 24, 82, 58, 37, 56, 82, 23, 78, 63, 64, 37, 66, 36, 41, 71, 48, 42, 26, 45,\n 26, 86, 64, 54]}, 'u500_03': {'capacity': 150, 'num_items': 500,\n 'items': [64, 42, 86, 65, 47, 68, 20, 45, 69, 78,\n 44, 96, 50, 27, 58, 55, 81, 87, 76, 38,\n 79, 71, 60, 76, 91, 69, 77, 57, 33, 22,\n 76, 51, 66, 90, 34, 46, 74, 62, 93, 74,\n 29, 22, 73, 26, 72, 41, 91, 88, 95, 35,\n 84, 32, 59, 56, 84, 71, 78, 82, 78, 52,\n 71, 26, 66, 84, 76, 95, 80, 50, 53, 30,\n 82, 38, 45, 99, 51, 98, 100, 88, 81,\n 77, 99, 97, 31, 54, 47, 45, 36, 96, 96,\n 74, 77, 98, 69, 22, 40, 39, 81, 90, 73,\n 84, 53, 73, 81, 51, 38, 43, 64, 28, 83,\n 28, 66, 22, 56, 61, 72, 69, 55, 20, 50,\n 52, 95, 89, 32, 60, 29, 90, 20, 90, 41,\n 37, 95, 20, 84, 33, 28, 40, 91, 39, 63,\n 66, 29, 74, 97, 41, 81, 53, 22, 32, 91,\n 61, 33, 91, 55, 56, 57, 44, 60, 55, 92,\n 39, 38, 100, 30, 65, 22, 78, 84, 32,\n 51, 52, 47, 62, 63, 25, 42, 59, 24, 88,\n 61, 71, 23, 48, 78, 85, 92, 39, 31, 76,\n 87, 54, 61, 66, 40, 22, 74, 99, 96, 73,\n 24, 43, 93, 47, 51, 22, 49, 39, 21, 72,\n 93, 72, 49, 68, 71, 82, 44, 25, 82, 74,\n 59, 28, 33, 61, 90, 97, 62, 42, 100,\n 50, 31, 84, 81, 27, 45, 84, 54, 34, 79,\n 100, 63, 48, 68, 46, 74, 65, 35, 66,\n 53, 27, 70, 86, 49, 45, 86, 74, 64, 73,\n 93, 34, 97, 80, 24, 87, 100, 75, 89,\n 78, 46, 31, 68, 63, 78, 28, 96, 54, 64,\n 31, 65, 90, 41, 47, 71, 51, 63, 44, 93,\n 46, 46, 83, 68, 57, 89, 35, 99, 39, 24,\n 69, 64, 25, 85, 65, 81, 61, 40, 64, 88,\n 43, 99, 53, 98, 70, 38, 75, 23, 80, 72,\n 97, 89, 80, 38, 30, 34, 22, 61, 48, 22,\n 28, 99, 55, 89, 67, 24, 27, 91, 90, 20,\n 36, 77, 44, 24, 60, 96, 83, 53, 76, 27,\n 91, 58, 78, 23, 31, 99, 42, 64, 39, 73,\n 43, 36, 76, 97, 41, 90, 24, 82, 55, 93,\n 63, 61, 39, 73, 54, 77, 100, 46, 69,\n 74, 41, 32, 56, 68, 98, 61, 28, 21, 30,\n 47, 43, 54, 33, 31, 38, 49, 40, 44, 93,\n 20, 81, 71, 36, 71, 36, 42, 56, 85, 23,\n 86, 88, 95, 61, 41, 34, 74, 37, 82, 30,\n 98, 86, 37, 93, 100, 69, 25, 54, 47,\n 58, 50, 87, 90, 45, 71, 70, 38, 49, 42,\n 33, 78, 48, 94, 99, 100, 84, 91, 27,\n 69, 52, 64, 99, 30, 34, 55, 96, 92, 48,\n 88, 76, 38, 73, 90, 99, 45, 84, 94, 82,\n 28, 35, 94, 100, 44, 23, 58, 23, 35,\n 84, 75, 30, 58, 61, 61, 100, 63, 99,\n 85, 60, 78, 56, 76, 61, 59, 93, 83, 84,\n 89, 59, 75, 32, 21, 62, 27, 64, 44,\n 83]},\n 'u500_04': {'capacity': 150, 'num_items': 500,\n 'items': [68, 90, 38, 98, 44, 66, 76, 67, 65, 81, 95, 62, 34, 33, 56, 75, 40, 72, 49, 95,\n 59, 40, 53, 27, 70, 27, 72, 92, 79, 66, 92, 47, 87, 32, 51, 94, 22, 79, 75, 70,\n 58, 85, 37, 68, 69, 47, 63, 37, 53, 90, 85, 88, 68, 100, 86, 93, 26, 44, 77,\n 72, 46, 58, 44, 49, 100, 72, 76, 74, 78, 30, 79, 30, 88, 29, 70, 69, 26, 53,\n 86, 48, 55, 30, 95, 22, 79, 94, 54, 43, 84, 51, 80, 90, 61, 43, 71, 72, 82, 83,\n 91, 56, 42, 45, 80, 73, 62, 95, 53, 40, 42, 63, 80, 79, 86, 59, 22, 62, 72, 51,\n 60, 55, 56, 92, 56, 55, 51, 34, 100, 89, 64, 99, 87, 74, 38, 28, 50, 86, 92,\n 98, 30, 30, 89, 51, 65, 31, 60, 85, 79, 39, 27, 61, 84, 41, 53, 77, 77, 94, 86,\n 91, 49, 47, 35, 28, 82, 73, 34, 92, 51, 35, 51, 47, 64, 89, 72, 89, 22, 52, 75,\n 85, 73, 83, 56, 58, 57, 64, 50, 66, 26, 80, 61, 54, 40, 89, 46, 45, 59, 51, 79,\n 73, 95, 42, 21, 64, 73, 68, 65, 100, 50, 81, 55, 71, 44, 63, 76, 36, 73, 74,\n 98, 36, 97, 23, 58, 50, 70, 75, 97, 76, 24, 72, 34, 36, 67, 45, 55, 94, 63,\n 100, 95, 54, 40, 62, 68, 87, 48, 37, 85, 73, 62, 22, 23, 33, 81, 41, 27, 95,\n 46, 69, 45, 39, 32, 98, 41, 46, 100, 86, 84, 39, 67, 34, 92, 59, 43, 21, 56,\n 88, 26, 35, 51, 22, 100, 96, 49, 95, 38, 62, 63, 97, 42, 62, 100, 43, 44, 77,\n 97, 94, 68, 23, 50, 36, 89, 58, 97, 27, 64, 65, 54, 58, 24, 35, 33, 63, 32, 50,\n 58, 90, 44, 50, 48, 21, 72, 75, 21, 74, 28, 95, 77, 69, 96, 24, 57, 85, 72, 96,\n 50, 83, 65, 62, 99, 93, 23, 77, 94, 31, 50, 33, 79, 73, 23, 55, 44, 78, 84, 66,\n 31, 59, 97, 95, 22, 76, 90, 66, 29, 100, 90, 92, 50, 49, 47, 43, 37, 40, 60,\n 52, 54, 99, 34, 46, 88, 97, 85, 39, 32, 51, 95, 54, 99, 86, 48, 90, 28, 25, 86,\n 39, 74, 26, 38, 60, 41, 67, 80, 33, 37, 62, 71, 87, 31, 72, 84, 84, 53, 85, 32,\n 24, 88, 54, 28, 36, 91, 61, 29, 68, 69, 35, 30, 88, 85, 87, 70, 70, 59, 26, 73,\n 27, 44, 27, 35, 38, 65, 21, 69, 59, 35, 70, 40, 84, 42, 92, 24, 46, 78, 60, 76,\n 43, 49, 79, 65, 24, 28, 43, 26, 93, 62, 91, 21, 21, 32, 34, 86, 27, 79, 34, 88,\n 93, 58, 77, 62, 87, 99, 61, 83, 75, 99, 93, 39, 85, 31, 69, 48, 67, 50, 24, 49,\n 82, 97, 86, 21, 86, 41, 100, 84, 77]},\n 'u500_05': {'capacity': 150, 'num_items': 500,\n 'items': [87, 70, 43, 62, 40, 37, 71, 34, 29, 70, 41, 78, 74, 51, 71, 47, 21, 32, 37, 80,\n 48, 93, 22, 46, 96, 44, 94, 99, 100, 65, 61, 34, 25, 35, 60, 52, 90, 81, 93,\n 74, 85, 43, 21, 89, 100, 56, 55, 88, 52, 63, 40, 41, 62, 35, 77, 72, 75, 93,\n 55, 95, 54, 87, 38, 84, 83, 88, 37, 65, 58, 89, 89, 48, 85, 25, 100, 28, 20,\n 96, 52, 100, 94, 94, 69, 94, 39, 62, 86, 43, 61, 88, 78, 72, 71, 31, 45, 72,\n 87, 60, 91, 100, 66, 44, 83, 23, 22, 81, 22, 55, 67, 73, 68, 42, 83, 40, 86,\n 63, 33, 24, 54, 48, 41, 56, 48, 29, 51, 78, 85, 68, 35, 99, 74, 42, 26, 49, 65,\n 92, 51, 43, 97, 91, 24, 79, 30, 58, 76, 59, 92, 94, 43, 31, 87, 59, 56, 74, 91,\n 88, 85, 70, 59, 80, 54, 66, 55, 61, 64, 80, 53, 80, 44, 74, 22, 91, 91, 83, 51,\n 57, 20, 83, 46, 54, 56, 76, 24, 41, 26, 37, 91, 52, 94, 94, 49, 61, 69, 79, 38,\n 78, 25, 57, 70, 81, 57, 34, 22, 58, 99, 39, 99, 29, 34, 58, 94, 46, 41, 56, 86,\n 92, 81, 82, 38, 42, 99, 59, 73, 57, 59, 67, 44, 29, 53, 54, 40, 83, 55, 66, 72,\n 80, 25, 92, 78, 97, 28, 99, 73, 66, 44, 59, 95, 53, 81, 83, 92, 61, 32, 31, 38,\n 29, 44, 90, 68, 35, 78, 56, 25, 26, 61, 90, 20, 43, 37, 65, 63, 39, 95, 87, 83,\n 97, 41, 87, 69, 75, 82, 45, 80, 78, 89, 98, 32, 24, 55, 63, 92, 33, 95, 80, 27,\n 62, 97, 36, 73, 67, 35, 82, 37, 61, 82, 45, 26, 56, 91, 53, 71, 78, 33, 20, 26,\n 97, 90, 30, 44, 86, 82, 25, 56, 34, 54, 97, 91, 42, 74, 83, 38, 44, 44, 26, 66,\n 35, 45, 80, 42, 97, 26, 61, 59, 92, 92, 81, 33, 86, 87, 100, 69, 25, 51, 32,\n 94, 50, 42, 21, 90, 52, 32, 66, 77, 22, 64, 51, 41, 81, 54, 70, 67, 84, 72, 47,\n 92, 82, 96, 58, 80, 95, 36, 60, 42, 41, 51, 29, 99, 57, 21, 48, 30, 65, 55, 62,\n 60, 49, 80, 63, 25, 35, 54, 27, 68, 64, 35, 52, 87, 40, 52, 41, 59, 56, 77, 41,\n 43, 73, 87, 56, 76, 29, 46, 39, 92, 40, 72, 54, 20, 56, 68, 27, 23, 62, 45, 95,\n 90, 27, 36, 79, 88, 51, 95, 96, 66, 57, 96, 25, 33, 84, 67, 75, 78, 61, 53, 42,\n 72, 40, 60, 99, 32, 99, 70, 39, 90, 73, 71, 23, 61, 49, 100, 35, 45, 34, 84,\n 49, 100, 75, 46, 85, 83, 93, 90, 68, 20, 100, 73, 25, 66, 70, 40, 83, 37, 29,\n 29, 87, 95, 42, 95, 100, 96, 55]},\n 'u500_06': {'capacity': 150, 'num_items': 500,\n 'items': [65, 58, 79, 76, 84, 63, 91, 81, 30, 57, 71, 67, 33, 27, 99, 36, 48, 66, 68, 66,\n 40, 87, 99, 59, 42, 50, 51, 87, 98, 64, 32, 41, 56, 85, 87, 95, 46, 75, 37, 54,\n 58, 82, 57, 26, 94, 31, 71, 95, 27, 29, 38, 37, 55, 94, 70, 90, 29, 98, 27, 95,\n 98, 95, 98, 51, 47, 71, 27, 61, 49, 66, 93, 89, 34, 60, 33, 97, 74, 95, 44, 96,\n 88, 89, 84, 52, 50, 53, 90, 94, 98, 46, 62, 68, 45, 77, 49, 82, 51, 95, 33, 94,\n 98, 75, 47, 42, 64, 34, 51, 68, 27, 42, 87, 65, 44, 62, 84, 75, 70, 44, 84, 54,\n 92, 58, 50, 61, 95, 59, 22, 24, 56, 59, 45, 54, 43, 70, 97, 97, 29, 42, 55, 67,\n 91, 26, 61, 65, 28, 26, 54, 96, 49, 46, 100, 68, 58, 43, 36, 78, 40, 22, 41,\n 82, 46, 58, 29, 97, 62, 69, 57, 67, 85, 32, 93, 43, 47, 99, 20, 81, 70, 91, 23,\n 80, 43, 81, 22, 76, 95, 29, 60, 50, 99, 38, 79, 20, 67, 63, 89, 85, 97, 100,\n 33, 100, 43, 31, 57, 45, 48, 72, 26, 66, 30, 81, 43, 62, 86, 64, 89, 22, 100,\n 73, 38, 63, 32, 31, 33, 88, 72, 74, 100, 57, 97, 49, 80, 98, 71, 82, 28, 67,\n 88, 57, 44, 78, 74, 47, 57, 96, 47, 82, 55, 90, 63, 55, 87, 100, 69, 94, 71,\n 91, 74, 76, 68, 82, 96, 85, 96, 85, 79, 71, 56, 86, 46, 55, 44, 35, 29, 42, 65,\n 49, 82, 73, 70, 63, 94, 63, 71, 86, 27, 93, 80, 42, 45, 93, 69, 76, 61, 29, 81,\n 46, 42, 74, 45, 88, 96, 40, 31, 47, 82, 60, 43, 20, 80, 69, 46, 90, 34, 81, 59,\n 43, 61, 28, 56, 32, 90, 60, 66, 70, 77, 43, 92, 85, 45, 74, 40, 51, 48, 30, 41,\n 63, 71, 43, 24, 91, 48, 65, 41, 34, 47, 88, 73, 57, 50, 68, 80, 34, 70, 96, 80,\n 26, 77, 53, 82, 78, 74, 87, 69, 97, 87, 64, 31, 77, 25, 60, 20, 66, 48, 80, 77,\n 90, 69, 61, 93, 41, 35, 28, 68, 59, 27, 34, 24, 56, 42, 29, 52, 42, 27, 83, 78,\n 40, 37, 21, 77, 43, 45, 76, 53, 36, 61, 52, 53, 41, 76, 83, 49, 38, 71, 64, 89,\n 48, 32, 69, 80, 88, 41, 46, 37, 60, 63, 20, 47, 40, 93, 46, 84, 77, 92, 51, 87,\n 49, 75, 58, 61, 83, 53, 22, 79, 80, 92, 96, 49, 53, 22, 50, 71, 73, 66, 23, 70,\n 76, 93, 46, 39, 40, 93, 41, 36, 60, 35, 25, 99, 79, 52, 22, 66, 44, 68, 73, 60,\n 56, 76, 95, 95, 53, 37, 68, 87, 20, 38, 95, 95, 86, 47, 68, 66, 37, 44, 47, 77,\n 26, 90, 97, 86, 57]}, 'u500_07': {'capacity': 150, 'num_items': 500,\n 'items': [72, 83, 38, 84, 82, 88, 47, 43, 59,\n 92, 78, 25, 25, 47, 65, 42, 41, 36,\n 54, 43, 87, 51, 65, 98, 82, 34, 21,\n 94, 100, 80, 95, 32, 23, 26, 93,\n 70, 96, 79, 68, 93, 74, 76, 99, 75,\n 44, 94, 93, 38, 44, 45, 49, 22, 39,\n 87, 74, 25, 59, 22, 44, 70, 51, 68,\n 33, 25, 77, 55, 75, 87, 42, 79, 50,\n 78, 43, 20, 88, 56, 93, 75, 56, 36,\n 70, 47, 94, 24, 35, 47, 26, 48, 40,\n 48, 77, 30, 36, 96, 63, 47, 22, 60,\n 51, 84, 90, 46, 98, 59, 94, 59, 54,\n 38, 79, 77, 73, 61, 21, 21, 83, 81,\n 34, 37, 76, 49, 23, 75, 79, 98,\n 100, 29, 88, 83, 80, 100, 56, 61,\n 31, 37, 43, 69, 78, 28, 41, 82, 56,\n 31, 25, 22, 46, 68, 63, 75, 64, 76,\n 65, 98, 77, 36, 21, 86, 63, 95, 61,\n 22, 45, 49, 35, 63, 43, 71, 23, 53,\n 100, 41, 50, 51, 26, 54, 62, 27,\n 68, 73, 79, 47, 53, 53, 56, 85, 93,\n 36, 97, 29, 65, 20, 32, 49, 83, 33,\n 49, 90, 93, 64, 71, 45, 59, 74, 77,\n 58, 91, 88, 60, 67, 44, 42, 89, 79,\n 40, 88, 95, 81, 73, 82, 23, 20, 22,\n 92, 75, 23, 74, 25, 79, 62, 48, 21,\n 74, 28, 78, 73, 31, 44, 28, 37, 77,\n 52, 23, 82, 97, 52, 90, 94, 28, 95,\n 37, 51, 29, 31, 81, 61, 24, 92, 70,\n 56, 100, 61, 85, 83, 53, 44, 70,\n 65, 25, 39, 71, 26, 63, 99, 64, 97,\n 88, 54, 91, 53, 96, 44, 49, 94, 63,\n 65, 90, 37, 30, 28, 53, 83, 41, 54,\n 89, 32, 49, 40, 80, 63, 89, 74, 89,\n 20, 25, 75, 31, 56, 92, 85, 40, 97,\n 56, 100, 55, 35, 27, 96, 89, 29,\n 44, 26, 49, 73, 72, 50, 52, 77, 35,\n 97, 79, 45, 75, 62, 91, 50, 37, 25,\n 65, 97, 62, 74, 81, 72, 100, 57,\n 49, 83, 23, 92, 63, 55, 81, 64, 88,\n 50, 74, 52, 25, 97, 48, 43, 49, 33,\n 86, 35, 71, 21, 90, 95, 88, 80, 93,\n 73, 60, 96, 65, 56, 32, 88, 67, 69,\n 63, 26, 51, 59, 85, 41, 91, 70, 92,\n 44, 53, 49, 91, 33, 57, 26, 99, 24,\n 48, 52, 92, 43, 46, 47, 96, 36, 88,\n 55, 55, 76, 51, 87, 44, 58, 34, 69,\n 43, 56, 37, 74, 82, 64, 75, 99, 36,\n 54, 76, 72, 21, 33, 61, 87, 54, 82,\n 94, 87, 46, 71, 83, 71, 44, 87, 20,\n 31, 67, 93, 100, 94, 97, 64, 63,\n 36, 89, 48, 34, 41, 42, 74, 30, 48,\n 73, 37, 100, 49, 58, 50, 50, 86,\n 79, 91, 98, 63, 24, 82, 24, 48, 26,\n 98, 82, 75, 62, 55, 82, 87, 74, 87,\n 32, 73, 28, 95, 84, 29, 82, 68, 70,\n 49, 88, 23, 78, 96]},\n 'u500_08': {'capacity': 150, 'num_items': 500,\n 'items': [73, 99, 36, 56, 65, 46, 60, 32, 77, 41, 32, 94, 77, 63, 35, 78, 24, 95, 96, 81,\n 86, 75, 36, 21, 48, 28, 95, 62, 91, 40, 26, 88, 43, 45, 22, 54, 28, 48, 88, 80,\n 35, 81, 69, 94, 96, 95, 67, 30, 29, 59, 40, 65, 31, 74, 39, 57, 95, 46, 32, 82,\n 55, 36, 47, 85, 80, 36, 31, 40, 82, 53, 59, 57, 31, 82, 72, 38, 69, 53, 74, 79,\n 97, 42, 49, 74, 86, 37, 89, 63, 75, 84, 38, 42, 59, 80, 23, 20, 95, 46, 98, 97,\n 64, 66, 84, 24, 25, 20, 68, 32, 38, 48, 27, 74, 86, 54, 81, 73, 77, 40, 48, 81,\n 86, 59, 87, 60, 27, 81, 22, 29, 62, 41, 76, 57, 31, 79, 30, 83, 29, 65, 97, 49,\n 52, 42, 20, 85, 89, 93, 39, 29, 33, 21, 26, 73, 28, 28, 38, 33, 96, 50, 73, 53,\n 31, 100, 27, 85, 37, 42, 79, 60, 95, 21, 87, 34, 46, 88, 57, 41, 66, 38, 79,\n 27, 85, 72, 83, 82, 94, 56, 24, 83, 32, 49, 78, 30, 33, 50, 37, 49, 25, 44, 86,\n 22, 54, 38, 81, 77, 39, 47, 22, 51, 40, 70, 83, 86, 69, 73, 31, 80, 84, 70, 55,\n 68, 27, 25, 25, 27, 48, 30, 83, 42, 26, 63, 72, 74, 83, 55, 36, 44, 95, 81, 73,\n 53, 63, 47, 88, 86, 48, 21, 89, 74, 70, 63, 56, 68, 67, 56, 44, 64, 75, 96, 80,\n 58, 75, 50, 43, 42, 31, 94, 64, 77, 89, 30, 45, 74, 53, 57, 56, 47, 31, 55, 58,\n 28, 72, 27, 35, 68, 68, 82, 67, 47, 24, 49, 40, 67, 96, 80, 88, 39, 93, 32, 47,\n 81, 99, 38, 51, 97, 31, 55, 40, 63, 93, 78, 30, 39, 55, 67, 24, 72, 71, 43, 31,\n 79, 77, 42, 73, 62, 93, 90, 50, 98, 36, 76, 72, 35, 48, 53, 33, 64, 51, 32, 82,\n 68, 55, 51, 84, 72, 50, 30, 21, 25, 43, 55, 56, 65, 73, 24, 100, 21, 47, 97,\n 90, 83, 75, 43, 61, 51, 32, 74, 63, 91, 21, 92, 71, 74, 42, 100, 21, 63, 72,\n 42, 54, 57, 42, 81, 68, 79, 38, 47, 21, 22, 55, 61, 40, 35, 76, 83, 100, 31,\n 62, 36, 75, 82, 50, 80, 38, 68, 21, 84, 72, 67, 84, 98, 39, 68, 86, 63, 98, 67,\n 75, 37, 35, 41, 63, 67, 57, 26, 53, 36, 56, 92, 89, 76, 49, 23, 23, 49, 24, 56,\n 74, 34, 64, 100, 82, 25, 30, 72, 82, 68, 67, 57, 57, 40, 33, 40, 27, 52, 89,\n 52, 97, 31, 48, 50, 57, 37, 77, 32, 97, 67, 93, 70, 20, 38, 71, 49, 78, 40, 94,\n 21, 66, 96, 86, 85, 99, 79, 85, 77, 68, 37, 41, 68, 27, 100, 96, 74, 46, 79,\n 43, 59, 50, 39, 42, 80]}, 'u500_09': {'capacity': 150, 'num_items': 500,\n 'items': [87, 62, 73, 65, 73, 72, 77, 85,\n 33, 39, 58, 100, 87, 24, 35,\n 34, 28, 70, 49, 36, 65, 27, 75,\n 99, 99, 59, 79, 99, 90, 64, 42,\n 82, 58, 56, 89, 80, 97, 82, 44,\n 92, 29, 39, 90, 99, 68, 40, 23,\n 95, 39, 77, 59, 74, 94, 67, 72,\n 90, 60, 49, 21, 20, 49, 33, 85,\n 84, 50, 95, 52, 31, 46, 96, 73,\n 66, 33, 90, 77, 79, 27, 91, 54,\n 62, 44, 78, 35, 62, 97, 25, 79,\n 31, 26, 87, 30, 24, 31, 24, 53,\n 90, 66, 21, 58, 28, 81, 61,\n 100, 33, 95, 77, 77, 75, 52,\n 58, 95, 47, 27, 29, 74, 84, 49,\n 25, 57, 90, 61, 59, 99, 70, 33,\n 25, 54, 66, 32, 20, 32, 47, 28,\n 71, 33, 55, 81, 56, 21, 83, 67,\n 46, 96, 50, 94, 55, 57, 100,\n 35, 50, 21, 97, 30, 34, 57, 74,\n 99, 63, 40, 96, 83, 37, 59, 72,\n 59, 50, 84, 88, 22, 97, 81, 22,\n 55, 31, 66, 23, 88, 89, 28, 77,\n 78, 41, 93, 94, 45, 84, 48, 75,\n 38, 68, 34, 37, 40, 78, 60, 94,\n 58, 71, 70, 30, 77, 34, 96, 58,\n 70, 61, 27, 55, 48, 80, 26, 59,\n 31, 55, 80, 75, 73, 48, 22, 35,\n 97, 46, 98, 48, 49, 28, 67, 94,\n 46, 46, 37, 45, 48, 42, 31, 67,\n 23, 98, 58, 55, 24, 60, 48, 95,\n 93, 49, 56, 90, 31, 24, 71, 39,\n 69, 32, 82, 75, 60, 39, 80, 61,\n 43, 34, 80, 69, 21, 59, 82, 54,\n 26, 51, 96, 76, 76, 45, 41, 73,\n 91, 23, 98, 90, 59, 43, 52, 48,\n 87, 97, 51, 72, 77, 59, 83, 65,\n 40, 79, 30, 31, 99, 40, 42, 66,\n 47, 67, 50, 72, 62, 95, 75, 81,\n 36, 36, 70, 89, 95, 62, 56, 23,\n 37, 50, 46, 30, 64, 94, 65, 55,\n 24, 28, 96, 31, 57, 72, 96, 63,\n 40, 79, 89, 97, 50, 37, 93, 52,\n 86, 74, 47, 84, 77, 48, 54, 97,\n 70, 29, 40, 74, 71, 46, 46, 63,\n 48, 74, 25, 77, 46, 80, 35, 56,\n 65, 49, 38, 26, 81, 80, 73, 38,\n 27, 97, 47, 88, 42, 62, 45, 33,\n 78, 35, 63, 25, 74, 63, 41, 81,\n 68, 78, 52, 30, 22, 100, 42,\n 53, 60, 58, 92, 74, 67, 72, 30,\n 48, 65, 23, 94, 99, 67, 57, 73,\n 44, 63, 53, 87, 54, 62, 100,\n 30, 20, 25, 94, 85, 68, 59, 82,\n 52, 100, 89, 49, 74, 44, 23,\n 39, 21, 65, 80, 93, 36, 97, 74,\n 37, 52, 94, 60, 77, 57, 71, 61,\n 92, 98, 86, 55, 89, 24, 88, 53,\n 85, 39, 89, 64, 45, 52, 71, 79,\n 23, 50, 95, 55, 36, 95, 41, 36,\n 94, 52, 36, 76, 72, 52, 42, 27,\n 61, 55, 64, 30, 22, 53, 71, 51,\n 37, 96, 74, 63, 54, 81, 77, 55,\n 29, 89, 41]},\n 'u500_10': {'capacity': 150, 'num_items': 500,\n 'items': [36, 76, 68, 31, 48, 56, 67, 48, 32, 46, 89, 40, 48, 39, 63, 74, 54, 80, 26, 40,\n 74, 99, 70, 66, 89, 79, 20, 87, 94, 76, 90, 84, 25, 93, 88, 28, 50, 77, 82, 96,\n 80, 82, 83, 39, 50, 35, 38, 40, 91, 84, 74, 96, 25, 70, 38, 77, 35, 71, 31, 98,\n 73, 31, 51, 34, 35, 40, 68, 100, 33, 52, 73, 39, 30, 82, 40, 32, 88, 58, 62,\n 79, 22, 45, 91, 69, 61, 83, 49, 87, 33, 54, 97, 100, 28, 61, 53, 80, 81, 68,\n 93, 87, 72, 31, 61, 53, 42, 24, 71, 75, 25, 59, 40, 70, 67, 43, 72, 91, 55, 82,\n 96, 28, 68, 46, 45, 95, 83, 100, 39, 40, 35, 72, 28, 58, 91, 95, 61, 72, 65,\n 47, 53, 45, 84, 80, 85, 99, 67, 39, 72, 83, 56, 27, 86, 45, 50, 52, 90, 70, 52,\n 45, 81, 23, 38, 60, 31, 58, 51, 74, 42, 79, 22, 28, 52, 34, 67, 85, 57, 49, 24,\n 90, 75, 60, 32, 84, 89, 71, 92, 69, 57, 35, 70, 57, 32, 48, 94, 79, 37, 77, 49,\n 72, 89, 91, 42, 82, 52, 46, 46, 96, 97, 87, 73, 55, 89, 67, 43, 28, 91, 88, 74,\n 49, 71, 20, 37, 20, 41, 98, 41, 36, 82, 87, 23, 31, 86, 92, 23, 31, 71, 100,\n 34, 27, 24, 54, 21, 60, 87, 77, 24, 100, 35, 76, 90, 87, 64, 37, 69, 74, 76,\n 89, 53, 76, 86, 72, 88, 62, 73, 100, 61, 57, 55, 76, 41, 45, 93, 42, 21, 68,\n 68, 56, 56, 47, 95, 23, 68, 77, 40, 74, 79, 88, 69, 82, 56, 89, 80, 49, 24, 57,\n 40, 20, 24, 77, 47, 75, 47, 39, 27, 63, 93, 64, 84, 63, 85, 52, 41, 28, 72, 63,\n 46, 24, 71, 22, 67, 28, 46, 47, 64, 54, 78, 32, 63, 82, 25, 97, 66, 66, 38, 37,\n 33, 78, 76, 35, 49, 68, 34, 99, 90, 82, 41, 81, 67, 82, 50, 46, 75, 85, 38, 62,\n 51, 98, 92, 56, 91, 67, 26, 67, 26, 71, 81, 74, 36, 70, 48, 27, 42, 94, 39, 54,\n 82, 49, 58, 27, 33, 26, 32, 23, 52, 74, 35, 46, 37, 57, 37, 90, 20, 40, 29, 43,\n 23, 58, 99, 83, 73, 38, 21, 47, 84, 22, 63, 93, 61, 74, 73, 48, 42, 52, 77, 31,\n 76, 33, 28, 54, 71, 66, 93, 69, 78, 37, 93, 43, 44, 51, 96, 44, 94, 91, 84, 49,\n 98, 46, 57, 27, 65, 30, 20, 29, 51, 99, 97, 74, 98, 37, 38, 21, 56, 91, 42, 49,\n 39, 44, 26, 66, 55, 63, 76, 22, 54, 31, 20, 63, 50, 55, 83, 89, 89, 63, 98, 86,\n 67, 85, 81, 45, 64, 44, 23, 25, 77, 62, 34, 72, 77, 91, 62, 25, 72, 38, 24, 25,\n 98, 84, 54, 20, 58, 38]}, 'u500_11': {'capacity': 150, 'num_items': 500,\n 'items': [52, 77, 82, 54, 60, 91, 86, 68,\n 29, 52, 42, 47, 55, 61, 70, 71,\n 24, 62, 36, 91, 66, 33, 57, 34,\n 36, 26, 89, 61, 61, 92, 79, 84,\n 47, 85, 72, 25, 35, 66, 72, 55,\n 66, 21, 94, 87, 66, 31, 72, 49,\n 55, 75, 44, 76, 77, 63, 59, 40,\n 67, 85, 83, 64, 29, 41, 23, 72,\n 70, 52, 41, 57, 26, 21, 84, 24,\n 48, 36, 71, 84, 21, 35, 92, 89,\n 59, 59, 24, 45, 96, 80, 32, 27,\n 25, 44, 100, 74, 60, 55, 86,\n 48, 100, 52, 53, 26, 99, 85,\n 43, 64, 70, 84, 75, 73, 28, 40,\n 75, 87, 89, 93, 93, 34, 58, 88,\n 21, 36, 38, 28, 70, 32, 70, 37,\n 42, 54, 25, 95, 79, 86, 25, 47,\n 37, 81, 79, 30, 67, 63, 99, 38,\n 64, 98, 84, 67, 38, 36, 93, 38,\n 43, 84, 35, 94, 83, 38, 85, 80,\n 86, 64, 79, 31, 91, 34, 46, 60,\n 22, 38, 22, 87, 20, 97, 76,\n 100, 81, 20, 34, 46, 100, 93,\n 66, 31, 23, 42, 22, 32, 58, 78,\n 41, 73, 99, 38, 87, 92, 58, 32,\n 25, 59, 45, 42, 63, 21, 53, 53,\n 26, 93, 42, 27, 51, 61, 99, 45,\n 84, 79, 95, 91, 23, 88, 40, 98,\n 21, 45, 30, 70, 46, 75, 25, 40,\n 53, 51, 44, 71, 79, 68, 43, 64,\n 82, 60, 78, 69, 95, 38, 59, 90,\n 22, 68, 46, 73, 69, 69, 25, 42,\n 83, 31, 36, 47, 82, 74, 72, 96,\n 87, 41, 21, 27, 42, 22, 31, 95,\n 38, 90, 94, 78, 97, 31, 35, 32,\n 82, 33, 87, 89, 70, 39, 41, 61,\n 48, 47, 57, 64, 82, 20, 37, 50,\n 32, 94, 72, 44, 90, 92, 82, 30,\n 89, 95, 56, 79, 21, 27, 91, 78,\n 69, 47, 36, 100, 20, 32, 43,\n 64, 68, 63, 42, 91, 61, 37, 36,\n 59, 99, 38, 26, 76, 81, 95, 22,\n 88, 40, 23, 64, 93, 55, 27, 28,\n 68, 78, 80, 99, 90, 52, 98, 57,\n 34, 51, 37, 38, 22, 44, 87, 92,\n 93, 43, 86, 51, 59, 86, 71, 83,\n 27, 49, 89, 38, 72, 56, 79, 63,\n 92, 90, 64, 46, 66, 93, 54, 59,\n 94, 87, 87, 35, 74, 57, 58, 33,\n 79, 50, 40, 92, 67, 99, 52, 36,\n 72, 63, 98, 69, 32, 61, 38, 32,\n 31, 42, 81, 31, 55, 81, 44, 71,\n 67, 93, 32, 69, 68, 93, 61, 42,\n 63, 85, 62, 71, 35, 40, 64, 22,\n 66, 92, 93, 66, 93, 22, 26, 97,\n 61, 58, 87, 26, 59, 43, 71, 65,\n 30, 55, 88, 40, 88, 78, 95, 61,\n 54, 23, 56, 38, 46, 41, 45, 51,\n 29, 50, 28, 73, 66, 30, 40, 98,\n 72, 88, 97, 94, 32, 46, 66, 92,\n 60, 21, 65, 64, 89, 93, 87, 57,\n 62, 48, 83, 76, 36, 28, 72, 50,\n 96, 46, 36, 76, 38, 88, 98, 25,\n 28]},\n 'u500_12': {'capacity': 150, 'num_items': 500,\n 'items': [20, 53, 71, 21, 86, 92, 39, 73, 24, 34, 64, 82, 30, 55, 42, 23, 46, 70, 64, 45,\n 26, 33, 69, 85, 82, 57, 30, 69, 99, 21, 68, 26, 62, 76, 63, 99, 51, 60, 71, 64,\n 96, 27, 74, 90, 35, 35, 70, 66, 50, 64, 73, 98, 61, 72, 24, 51, 78, 93, 28, 76,\n 77, 51, 90, 38, 79, 87, 94, 78, 66, 53, 23, 32, 75, 27, 53, 95, 48, 29, 54, 85,\n 41, 52, 62, 74, 82, 93, 38, 98, 94, 60, 21, 49, 57, 32, 73, 81, 43, 73, 97, 32,\n 24, 96, 56, 61, 42, 82, 58, 91, 27, 85, 43, 59, 70, 60, 91, 81, 89, 20, 96, 40,\n 54, 24, 20, 31, 70, 65, 75, 92, 33, 90, 20, 55, 75, 89, 75, 70, 52, 73, 47, 85,\n 44, 35, 25, 41, 41, 25, 71, 85, 88, 67, 33, 27, 44, 83, 45, 84, 84, 62, 30, 43,\n 35, 74, 23, 65, 38, 27, 70, 63, 81, 78, 31, 40, 23, 32, 38, 92, 100, 31, 54,\n 70, 48, 20, 36, 78, 73, 90, 54, 100, 60, 67, 69, 79, 24, 67, 87, 39, 30, 91,\n 26, 41, 36, 75, 75, 96, 20, 47, 27, 28, 51, 75, 28, 42, 67, 70, 47, 20, 71, 81,\n 66, 24, 95, 87, 78, 55, 75, 58, 81, 54, 94, 93, 45, 91, 100, 48, 62, 44, 51,\n 94, 96, 74, 81, 31, 71, 37, 88, 26, 83, 74, 31, 48, 70, 27, 46, 27, 96, 36, 52,\n 75, 22, 92, 29, 68, 64, 21, 76, 40, 97, 73, 95, 45, 26, 47, 51, 78, 89, 23, 61,\n 23, 74, 31, 97, 56, 74, 100, 21, 51, 45, 40, 50, 94, 55, 77, 60, 21, 91, 37,\n 80, 52, 91, 57, 64, 60, 35, 93, 43, 63, 31, 32, 21, 55, 80, 81, 26, 39, 61, 99,\n 94, 80, 41, 96, 62, 39, 62, 23, 34, 45, 58, 69, 48, 32, 96, 25, 73, 76, 99, 35,\n 92, 71, 28, 75, 91, 42, 64, 91, 56, 43, 78, 51, 63, 49, 32, 25, 70, 72, 66, 21,\n 26, 87, 50, 85, 66, 41, 26, 100, 82, 73, 60, 57, 90, 20, 35, 67, 39, 32, 31,\n 90, 43, 25, 54, 93, 50, 35, 51, 91, 48, 22, 95, 96, 100, 22, 72, 98, 46, 94,\n 41, 62, 21, 48, 89, 29, 79, 88, 90, 66, 82, 50, 98, 71, 31, 52, 26, 63, 70, 33,\n 74, 86, 72, 67, 52, 53, 57, 63, 36, 78, 41, 69, 44, 44, 66, 46, 68, 99, 52, 98,\n 52, 69, 37, 47, 23, 28, 49, 61, 44, 55, 97, 55, 49, 79, 78, 22, 35, 78, 100,\n 25, 62, 43, 63, 49, 75, 33, 36, 44, 72, 92, 61, 94, 43, 89, 56, 34, 37, 77, 36,\n 68, 92, 31, 38, 89, 67, 96, 79, 51, 99, 59, 82, 64, 95, 48, 51, 95, 65, 73, 81,\n 72, 59, 84, 25, 78, 73, 51]}, 'u500_13': {'capacity': 150, 'num_items': 500,\n 'items': [88, 24, 89, 54, 78, 70, 93,\n 87, 43, 45, 22, 53, 29, 30,\n 95, 28, 58, 56, 84, 68, 30,\n 27, 80, 79, 68, 52, 59, 64,\n 58, 36, 50, 94, 55, 88, 45,\n 32, 37, 62, 20, 68, 67, 53,\n 45, 96, 29, 100, 25, 36,\n 50, 60, 53, 39, 77, 91, 55,\n 22, 80, 72, 56, 62, 90, 30,\n 60, 100, 41, 61, 86, 96,\n 92, 71, 35, 34, 28, 44, 58,\n 21, 88, 35, 62, 35, 47,\n 100, 21, 63, 22, 49, 46,\n 54, 38, 38, 76, 78, 43, 39,\n 84, 48, 100, 38, 25, 78,\n 86, 28, 22, 68, 64, 54, 21,\n 66, 75, 97, 35, 40, 85, 91,\n 83, 40, 42, 89, 51, 30, 83,\n 20, 21, 25, 20, 60, 79, 31,\n 91, 76, 41, 64, 87, 62, 95,\n 36, 22, 74, 58, 65, 50, 73,\n 70, 49, 85, 36, 48, 66, 96,\n 77, 50, 64, 66, 65, 61, 57,\n 79, 52, 22, 69, 36, 50, 61,\n 93, 23, 54, 91, 62, 91, 82,\n 37, 56, 99, 80, 29, 69, 57,\n 84, 47, 93, 94, 25, 69, 93,\n 96, 72, 87, 96, 94, 40, 61,\n 87, 85, 85, 92, 90, 24, 24,\n 69, 57, 92, 55, 30, 37, 57,\n 98, 74, 25, 52, 93, 40, 56,\n 46, 21, 40, 36, 79, 60, 76,\n 61, 90, 44, 44, 37, 81, 77,\n 95, 22, 69, 45, 26, 63,\n 100, 68, 63, 47, 61, 58,\n 93, 97, 91, 73, 36, 27, 32,\n 20, 22, 27, 93, 79, 63, 30,\n 40, 68, 72, 89, 26, 50, 28,\n 49, 55, 79, 100, 37, 75,\n 85, 79, 48, 31, 91, 82, 76,\n 40, 30, 24, 65, 39, 87, 20,\n 75, 65, 94, 95, 85, 64, 37,\n 63, 71, 44, 41, 52, 21,\n 100, 53, 27, 66, 22, 84,\n 59, 43, 85, 26, 83, 33, 55,\n 72, 38, 89, 80, 39, 45, 35,\n 37, 84, 87, 32, 64, 22, 35,\n 36, 77, 22, 70, 28, 30, 41,\n 59, 20, 37, 89, 53, 76, 75,\n 96, 43, 48, 52, 34, 28, 34,\n 76, 52, 54, 35, 31, 45, 70,\n 72, 49, 45, 59, 56, 64, 56,\n 31, 80, 58, 72, 100, 39,\n 21, 59, 75, 27, 88, 80, 84,\n 21, 39, 77, 20, 63, 47, 84,\n 50, 94, 28, 20, 36, 94, 57,\n 38, 61, 68, 73, 92, 80, 63,\n 58, 74, 97, 36, 30, 85, 55,\n 71, 68, 58, 98, 80, 66, 24,\n 76, 38, 45, 84, 67, 59, 54,\n 24, 49, 62, 71, 90, 27, 62,\n 20, 89, 39, 32, 55, 64, 68,\n 20, 64, 67, 73, 45, 77, 82,\n 78, 52, 28, 59, 93, 35, 71,\n 84, 97, 38, 65, 86, 93, 21,\n 99, 32, 74, 64, 30, 66, 79,\n 80, 25, 37, 84, 77, 75, 73,\n 89, 47, 34, 56, 70, 64, 32,\n 26, 83, 94, 64, 50, 40, 36,\n 61, 36, 66, 27, 53, 99, 22,\n 24, 23, 86, 99, 65, 78, 24,\n 27, 59, 29, 73, 64, 81, 49,\n 92, 25, 63, 30, 96, 100,\n 39]},\n 'u500_14': {'capacity': 150, 'num_items': 500,\n 'items': [36, 35, 92, 88, 49, 89, 23, 86, 80, 65, 21, 47, 55, 27, 99, 35, 40, 88, 45, 90,\n 54, 40, 24, 41, 91, 73, 99, 59, 96, 85, 72, 32, 20, 36, 61, 36, 39, 24, 50, 94,\n 22, 63, 45, 48, 27, 56, 51, 56, 83, 41, 49, 70, 90, 75, 85, 58, 47, 98, 26, 44,\n 31, 32, 36, 74, 48, 34, 96, 36, 96, 35, 39, 59, 38, 52, 34, 96, 45, 77, 29, 59,\n 76, 48, 95, 78, 77, 60, 66, 68, 22, 34, 46, 73, 92, 20, 34, 39, 76, 100, 76,\n 24, 42, 79, 72, 74, 69, 27, 69, 26, 97, 71, 78, 67, 42, 62, 97, 20, 43, 79, 30,\n 81, 69, 33, 47, 58, 83, 28, 20, 48, 29, 76, 21, 69, 71, 93, 67, 40, 74, 49, 51,\n 71, 27, 47, 28, 100, 74, 74, 95, 23, 63, 38, 35, 78, 27, 76, 52, 93, 32, 38,\n 71, 64, 83, 49, 44, 66, 100, 21, 97, 95, 51, 55, 97, 28, 77, 98, 65, 20, 44,\n 60, 38, 31, 61, 81, 97, 31, 41, 92, 26, 96, 48, 52, 49, 47, 42, 53, 82, 99, 90,\n 20, 41, 88, 21, 94, 87, 50, 61, 84, 62, 54, 89, 69, 43, 52, 42, 93, 64, 85, 86,\n 42, 64, 44, 45, 82, 20, 87, 27, 29, 75, 55, 97, 20, 86, 48, 24, 38, 56, 25, 70,\n 80, 78, 21, 62, 64, 48, 69, 22, 87, 61, 58, 77, 41, 86, 95, 58, 65, 88, 62, 96,\n 79, 30, 100, 56, 79, 49, 68, 55, 82, 45, 100, 92, 20, 49, 69, 67, 74, 44, 61,\n 20, 86, 52, 89, 83, 78, 100, 25, 100, 73, 21, 100, 52, 47, 48, 95, 71, 22, 79,\n 97, 50, 85, 68, 44, 74, 74, 75, 23, 52, 83, 76, 93, 100, 85, 77, 78, 30, 78,\n 89, 45, 56, 73, 81, 53, 91, 52, 44, 80, 47, 56, 70, 30, 52, 52, 47, 95, 98, 75,\n 81, 76, 21, 62, 51, 57, 56, 56, 46, 54, 36, 100, 62, 51, 75, 35, 72, 47, 27,\n 86, 27, 33, 25, 30, 72, 98, 52, 34, 31, 21, 36, 61, 41, 57, 81, 20, 47, 26, 47,\n 96, 39, 80, 90, 96, 78, 46, 92, 31, 83, 91, 68, 85, 73, 49, 46, 90, 59, 84, 25,\n 23, 49, 98, 25, 87, 75, 32, 95, 39, 44, 100, 40, 69, 75, 25, 71, 97, 91, 62,\n 26, 96, 69, 76, 83, 64, 25, 63, 33, 30, 77, 51, 100, 84, 22, 60, 37, 52, 58,\n 75, 99, 98, 35, 71, 43, 21, 64, 69, 62, 81, 71, 96, 73, 76, 74, 100, 95, 70,\n 59, 44, 88, 100, 45, 73, 57, 70, 93, 66, 95, 34, 34, 62, 95, 60, 26, 33, 74,\n 82, 62, 46, 87, 26, 93, 61, 38, 73, 92, 93, 57, 98, 97, 24, 67, 71, 82, 56, 81,\n 34, 56, 55, 60, 37, 31, 66, 93, 96, 45, 32]},\n 'u500_15': {'capacity': 150, 'num_items': 500,\n 'items': [77, 34, 89, 26, 27, 50, 36, 44, 87, 37, 71, 26, 50, 47, 70, 91, 76, 99, 21, 32,\n 81, 51, 45, 63, 90, 35, 38, 82, 55, 48, 52, 42, 84, 74, 75, 80, 43, 29, 82, 77,\n 43, 93, 75, 46, 45, 61, 88, 28, 70, 96, 98, 33, 56, 34, 49, 74, 67, 63, 42, 68,\n 93, 29, 27, 30, 50, 89, 26, 36, 71, 32, 28, 49, 83, 52, 55, 81, 83, 25, 42, 56,\n 88, 42, 91, 48, 54, 42, 74, 88, 72, 30, 61, 20, 61, 22, 44, 89, 55, 54, 33, 54,\n 79, 32, 89, 74, 37, 56, 60, 34, 75, 62, 68, 84, 58, 34, 33, 37, 75, 51, 61, 91,\n 79, 38, 34, 64, 85, 83, 75, 32, 31, 35, 56, 45, 24, 82, 51, 42, 63, 69, 74, 85,\n 35, 43, 49, 47, 26, 68, 99, 32, 70, 62, 89, 81, 65, 56, 57, 73, 67, 61, 21, 35,\n 31, 74, 50, 87, 81, 98, 46, 76, 39, 51, 24, 57, 87, 26, 36, 98, 56, 66, 61, 31,\n 46, 71, 88, 48, 58, 47, 51, 93, 64, 29, 93, 72, 82, 61, 90, 93, 59, 68, 50, 65,\n 100, 63, 40, 51, 50, 74, 63, 56, 51, 89, 97, 69, 87, 24, 89, 42, 86, 55, 29,\n 87, 33, 21, 22, 85, 42, 98, 46, 68, 28, 63, 66, 89, 90, 58, 48, 88, 66, 62, 99,\n 80, 79, 82, 52, 71, 52, 21, 20, 45, 70, 87, 35, 56, 88, 59, 89, 42, 30, 98, 65,\n 88, 88, 88, 22, 48, 77, 69, 83, 78, 93, 70, 85, 65, 100, 44, 93, 71, 38, 29,\n 28, 72, 49, 55, 64, 52, 75, 68, 65, 55, 43, 69, 89, 34, 85, 73, 38, 20, 41, 79,\n 63, 82, 34, 45, 63, 53, 34, 65, 98, 78, 40, 91, 23, 69, 32, 79, 69, 80, 35,\n 100, 98, 56, 93, 100, 55, 27, 42, 90, 75, 69, 24, 100, 66, 55, 64, 91, 44, 65,\n 92, 50, 63, 88, 86, 35, 67, 89, 83, 87, 85, 65, 78, 59, 72, 77, 26, 23, 64, 37,\n 25, 87, 37, 76, 57, 57, 33, 20, 63, 90, 66, 27, 53, 25, 26, 67, 57, 45, 32, 49,\n 53, 95, 56, 21, 89, 21, 46, 88, 30, 78, 79, 24, 30, 85, 43, 59, 67, 30, 78, 52,\n 92, 44, 95, 39, 90, 77, 90, 65, 38, 98, 80, 78, 20, 99, 46, 36, 71, 73, 62, 48,\n 36, 66, 75, 34, 93, 53, 32, 35, 69, 39, 96, 57, 42, 71, 76, 31, 81, 22, 47, 42,\n 48, 31, 80, 55, 52, 21, 80, 44, 83, 71, 43, 91, 88, 96, 48, 77, 66, 29, 77, 60,\n 75, 70, 65, 30, 76, 71, 55, 67, 56, 88, 78, 54, 58, 51, 28, 73, 32, 77, 45, 53,\n 21, 91, 30, 50, 57, 37, 87, 39, 33, 49, 99, 69, 74, 85, 46, 85, 51, 61, 40, 32,\n 52, 68, 74, 63]}, 'u500_16': {'capacity': 150, 'num_items': 500,\n 'items': [62, 99, 64, 96, 92, 87, 83, 86, 39, 83,\n 60, 31, 71, 92, 24, 49, 59, 93, 50, 83,\n 55, 56, 43, 61, 99, 87, 73, 80, 83, 96,\n 99, 82, 79, 73, 20, 60, 77, 93, 74, 72,\n 80, 73, 38, 30, 52, 75, 50, 82, 83, 96,\n 46, 38, 55, 42, 64, 66, 98, 21, 80, 60,\n 78, 25, 76, 44, 79, 72, 25, 86, 93,\n 100, 27, 33, 75, 28, 43, 29, 65, 94,\n 74, 69, 22, 66, 67, 44, 37, 38, 30, 67,\n 27, 20, 48, 39, 58, 93, 59, 37, 95, 45,\n 63, 37, 41, 90, 63, 25, 99, 32, 90, 69,\n 50, 65, 84, 60, 25, 80, 65, 31, 45, 90,\n 26, 55, 100, 97, 98, 36, 44, 21, 86,\n 46, 68, 75, 97, 35, 38, 92, 99, 64, 48,\n 89, 82, 96, 72, 75, 62, 76, 64, 44, 90,\n 36, 23, 52, 81, 77, 66, 27, 54, 45, 75,\n 100, 38, 36, 45, 63, 66, 63, 43, 23,\n 46, 59, 60, 58, 77, 72, 51, 22, 59, 48,\n 59, 58, 91, 72, 26, 74, 70, 90, 71, 52,\n 63, 36, 61, 38, 69, 28, 62, 64, 77, 50,\n 96, 23, 56, 64, 81, 40, 88, 60, 22, 65,\n 98, 36, 37, 58, 64, 57, 42, 73, 21, 96,\n 37, 88, 63, 90, 95, 73, 95, 77, 49, 81,\n 28, 99, 49, 77, 36, 26, 93, 84, 41, 74,\n 41, 35, 20, 60, 91, 79, 28, 86, 70, 57,\n 78, 23, 40, 32, 75, 24, 64, 48, 23, 87,\n 56, 74, 62, 21, 81, 52, 46, 89, 67, 28,\n 29, 99, 36, 29, 38, 93, 93, 36, 65, 81,\n 65, 48, 22, 31, 23, 30, 69, 75, 21, 62,\n 75, 77, 33, 79, 65, 84, 54, 82, 66, 81,\n 70, 70, 87, 25, 26, 76, 72, 45, 36, 38,\n 60, 61, 76, 41, 25, 93, 29, 81, 21, 24,\n 77, 69, 32, 26, 85, 25, 90, 20, 36, 20,\n 71, 66, 87, 68, 54, 43, 82, 46, 81, 52,\n 83, 98, 77, 24, 34, 78, 65, 51, 49, 31,\n 89, 35, 93, 29, 31, 42, 86, 90, 96, 64,\n 69, 59, 74, 31, 78, 77, 87, 87, 72, 29,\n 100, 62, 78, 22, 48, 79, 43, 92, 30,\n 78, 22, 64, 83, 52, 29, 74, 49, 61, 27,\n 35, 56, 61, 70, 78, 34, 52, 39, 22, 95,\n 25, 81, 85, 77, 94, 79, 90, 66, 60, 83,\n 30, 87, 20, 38, 86, 35, 35, 88, 69, 50,\n 38, 52, 95, 73, 50, 50, 48, 43, 74, 68,\n 23, 20, 37, 25, 78, 46, 61, 96, 50, 89,\n 43, 26, 52, 70, 93, 40, 24, 67, 88, 74,\n 44, 83, 33, 77, 94, 77, 89, 20, 75,\n 100, 49, 86, 66, 20, 79, 81, 54, 69,\n 69, 88, 87, 88, 69, 34, 84, 67, 24, 94,\n 50, 41, 20, 48, 94, 29, 40, 51, 91, 41,\n 50, 47, 68, 74, 55, 84, 51, 53, 46, 24,\n 62, 44, 62, 76, 46, 94, 44]},\n 'u500_17': {'capacity': 150, 'num_items': 500,\n 'items': [67, 25, 24, 33, 75, 71, 38, 24, 62, 71, 88, 83, 34, 49, 91, 34, 33, 38, 85, 83,\n 39, 68, 33, 99, 41, 47, 24, 32, 25, 98, 66, 99, 96, 28, 98, 91, 60, 74, 64, 63,\n 31, 43, 94, 32, 23, 95, 28, 40, 52, 77, 38, 48, 79, 40, 42, 54, 39, 42, 30, 54,\n 95, 31, 71, 23, 58, 94, 70, 56, 61, 41, 37, 45, 21, 54, 74, 44, 92, 90, 92, 89,\n 26, 94, 79, 31, 67, 36, 91, 73, 98, 52, 67, 75, 61, 37, 64, 29, 56, 34, 87, 26,\n 42, 100, 40, 29, 78, 70, 59, 27, 43, 59, 82, 63, 76, 52, 28, 66, 56, 83, 62,\n 98, 55, 98, 57, 49, 95, 89, 57, 69, 79, 77, 44, 22, 70, 87, 91, 43, 42, 40, 67,\n 59, 49, 99, 60, 22, 20, 35, 23, 36, 98, 82, 82, 57, 85, 83, 85, 56, 66, 37, 41,\n 33, 82, 21, 42, 99, 78, 72, 36, 20, 91, 34, 44, 90, 88, 89, 64, 96, 78, 30, 78,\n 57, 51, 30, 96, 90, 35, 49, 69, 49, 77, 80, 24, 44, 67, 28, 48, 80, 35, 46, 44,\n 40, 76, 99, 86, 84, 93, 25, 71, 25, 66, 27, 80, 57, 96, 51, 28, 82, 94, 48, 40,\n 65, 54, 92, 23, 72, 81, 37, 71, 72, 40, 95, 31, 39, 25, 90, 77, 73, 25, 57, 67,\n 21, 23, 70, 39, 35, 68, 91, 21, 21, 46, 57, 67, 60, 24, 89, 82, 72, 20, 44, 37,\n 91, 29, 27, 84, 91, 87, 34, 31, 20, 73, 36, 99, 29, 21, 57, 74, 38, 78, 98, 69,\n 43, 84, 77, 61, 79, 91, 49, 89, 32, 23, 83, 21, 90, 85, 77, 100, 94, 23, 52,\n 71, 84, 85, 98, 31, 20, 69, 92, 25, 74, 97, 34, 61, 47, 87, 28, 82, 85, 97, 93,\n 40, 23, 37, 46, 70, 94, 30, 74, 47, 57, 33, 32, 82, 67, 53, 80, 64, 21, 48, 57,\n 43, 64, 88, 25, 27, 90, 67, 87, 67, 28, 71, 21, 20, 72, 93, 44, 86, 85, 39, 78,\n 54, 71, 48, 74, 54, 93, 52, 53, 51, 48, 62, 36, 48, 98, 26, 70, 50, 42, 32, 36,\n 36, 85, 35, 59, 53, 60, 70, 66, 64, 60, 29, 52, 41, 28, 39, 96, 22, 44, 43, 83,\n 64, 55, 50, 52, 99, 71, 54, 31, 34, 80, 82, 82, 77, 54, 67, 66, 58, 49, 57, 37,\n 27, 83, 68, 86, 92, 65, 31, 96, 100, 45, 68, 58, 29, 53, 80, 57, 61, 27, 87,\n 86, 51, 73, 37, 67, 77, 25, 38, 88, 93, 86, 23, 98, 77, 27, 40, 85, 71, 73, 57,\n 96, 25, 25, 62, 30, 94, 39, 68, 53, 36, 62, 66, 44, 38, 81, 59, 96, 83, 82, 46,\n 48, 67, 79, 25, 32, 74, 45, 70, 81, 24, 73, 22, 74, 69, 36, 43, 73, 52, 69, 95,\n 96, 40, 67]}, 'u500_18': {'capacity': 150, 'num_items': 500,\n 'items': [42, 100, 22, 21, 56, 78, 89, 36, 93, 60,\n 70, 30, 89, 48, 71, 55, 99, 40, 84, 74, 95,\n 73, 86, 36, 85, 91, 47, 63, 44, 87, 83, 56,\n 57, 86, 46, 69, 75, 97, 59, 93, 45, 64, 49,\n 92, 86, 70, 75, 43, 94, 52, 87, 70, 77, 21,\n 86, 86, 46, 27, 30, 38, 96, 66, 99, 90, 87,\n 28, 99, 26, 45, 92, 59, 70, 77, 39, 38, 76,\n 46, 43, 98, 95, 52, 76, 40, 27, 22, 58, 47,\n 35, 93, 51, 86, 78, 64, 83, 43, 61, 23, 55,\n 95, 32, 24, 83, 42, 54, 69, 25, 62, 48, 20,\n 40, 99, 44, 39, 22, 92, 20, 75, 54, 49, 53,\n 60, 85, 43, 83, 98, 32, 44, 68, 66, 52, 86,\n 95, 77, 67, 70, 21, 89, 24, 27, 26, 96, 63,\n 82, 88, 22, 24, 84, 59, 54, 54, 22, 74, 90,\n 79, 66, 94, 68, 67, 55, 53, 30, 97, 66, 33,\n 26, 95, 88, 66, 72, 23, 28, 40, 41, 93, 76,\n 31, 34, 97, 76, 58, 76, 69, 82, 40, 28, 22,\n 46, 20, 91, 68, 71, 73, 85, 93, 83, 88, 27,\n 69, 29, 45, 56, 85, 50, 29, 89, 74, 74, 28,\n 97, 45, 23, 74, 96, 87, 22, 39, 65, 43,\n 100, 63, 55, 50, 85, 34, 29, 60, 77, 52,\n 48, 93, 34, 57, 68, 51, 54, 66, 99, 45, 29,\n 90, 59, 58, 55, 59, 38, 22, 82, 59, 23, 34,\n 81, 90, 91, 79, 38, 76, 40, 47, 85, 50, 50,\n 92, 25, 77, 76, 95, 58, 91, 66, 55, 80, 93,\n 33, 84, 38, 39, 76, 85, 81, 27, 66, 67, 51,\n 30, 54, 22, 75, 67, 85, 98, 89, 72, 93, 82,\n 53, 85, 40, 82, 56, 100, 32, 48, 88, 50,\n 80, 56, 60, 86, 64, 88, 49, 94, 23, 57, 95,\n 34, 49, 93, 51, 30, 76, 79, 73, 83, 27, 86,\n 38, 28, 27, 82, 21, 31, 84, 52, 71, 79, 44,\n 24, 97, 21, 69, 29, 84, 77, 76, 62, 31, 74,\n 26, 66, 68, 36, 32, 57, 52, 37, 48, 97, 20,\n 43, 89, 64, 61, 95, 77, 79, 42, 76, 78, 26,\n 64, 93, 77, 67, 87, 40, 65, 50, 95, 94, 57,\n 53, 51, 25, 41, 84, 88, 69, 24, 80, 34, 32,\n 56, 42, 95, 63, 21, 53, 52, 45, 39, 54, 58,\n 73, 41, 91, 65, 88, 61, 28, 57, 33, 29, 55,\n 45, 77, 55, 86, 60, 46, 33, 23, 35, 66, 81,\n 52, 28, 26, 71, 83, 61, 35, 56, 44, 67, 56,\n 90, 47, 33, 88, 84, 32, 27, 48, 28, 83, 62,\n 52, 45, 65, 65, 31, 42, 25, 43, 43, 42, 85,\n 50, 46, 58, 51, 74, 59, 79, 55, 51, 21, 65,\n 91, 33, 100, 91, 39, 87, 28, 70, 37, 57,\n 31, 65, 81, 61, 52, 22, 95, 90, 42, 67, 39,\n 57, 90, 53, 45, 91, 94, 84, 46, 78, 55]},\n 'u500_19': {'capacity': 150, 'num_items': 500,\n 'items': [64, 28, 27, 36, 35, 34, 22, 58, 53, 74, 24, 44, 99, 33, 90, 92, 28, 39, 67, 41,\n 46, 47, 36, 27, 23, 79, 100, 26, 72, 93, 60, 72, 28, 81, 97, 48, 90, 100, 21,\n 26, 51, 36, 76, 48, 43, 21, 100, 65, 48, 45, 78, 33, 37, 34, 72, 25, 23, 29,\n 97, 79, 39, 21, 54, 72, 64, 30, 77, 83, 95, 39, 20, 100, 46, 24, 87, 75, 24,\n 83, 55, 33, 70, 65, 93, 92, 68, 34, 67, 72, 24, 95, 68, 22, 34, 91, 89, 51, 83,\n 81, 31, 96, 83, 80, 52, 58, 88, 65, 74, 81, 33, 46, 94, 37, 49, 60, 80, 87, 85,\n 32, 97, 20, 92, 93, 30, 34, 27, 29, 49, 98, 87, 82, 34, 36, 21, 42, 35, 99, 62,\n 38, 23, 70, 76, 99, 45, 60, 28, 96, 86, 94, 53, 46, 92, 64, 50, 84, 90, 99, 80,\n 35, 77, 48, 78, 20, 23, 99, 74, 23, 35, 91, 94, 31, 28, 36, 44, 99, 43, 23, 57,\n 36, 71, 25, 40, 85, 87, 57, 63, 27, 100, 73, 52, 21, 56, 72, 28, 44, 25, 39,\n 28, 62, 49, 32, 44, 27, 69, 21, 82, 50, 77, 31, 71, 80, 71, 38, 76, 65, 46, 71,\n 46, 50, 31, 96, 21, 49, 37, 51, 82, 83, 48, 97, 96, 74, 90, 37, 21, 63, 66, 71,\n 84, 31, 64, 94, 90, 80, 43, 92, 78, 62, 31, 46, 45, 89, 95, 32, 57, 95, 91, 37,\n 99, 31, 28, 70, 34, 93, 70, 24, 97, 95, 32, 67, 91, 35, 28, 36, 23, 95, 93, 22,\n 43, 96, 39, 55, 83, 53, 90, 29, 52, 41, 24, 67, 66, 76, 50, 32, 73, 87, 36, 26,\n 61, 26, 48, 94, 45, 37, 84, 24, 100, 43, 51, 29, 63, 97, 49, 42, 93, 26, 99,\n 27, 45, 85, 67, 86, 68, 59, 41, 68, 54, 30, 89, 51, 40, 79, 72, 32, 86, 88, 44,\n 52, 45, 43, 21, 38, 30, 34, 86, 85, 100, 21, 36, 55, 26, 49, 52, 85, 62, 67,\n 84, 98, 66, 83, 66, 89, 50, 92, 57, 55, 52, 78, 93, 45, 25, 75, 58, 46, 55, 23,\n 81, 86, 21, 58, 100, 61, 41, 81, 38, 55, 60, 82, 51, 90, 44, 37, 22, 75, 60,\n 74, 38, 91, 43, 36, 37, 42, 48, 45, 57, 21, 25, 91, 55, 44, 56, 97, 76, 71, 98,\n 26, 97, 33, 77, 59, 58, 40, 44, 32, 35, 37, 53, 88, 78, 69, 77, 67, 56, 50, 95,\n 72, 69, 42, 35, 54, 49, 28, 88, 56, 27, 38, 92, 85, 41, 45, 94, 78, 94, 77, 20,\n 89, 68, 74, 56, 83, 46, 37, 68, 32, 27, 28, 33, 42, 25, 80, 29, 43, 36, 78, 88,\n 38, 61, 71, 38, 89, 88, 58, 100, 78, 65, 50, 77, 45, 64, 58, 70, 62, 75, 87,\n 84, 57, 46, 73, 51, 97, 90, 23]}}\n\n# Data from the Weibull 5k test dataset, containing 5 bin packing instances\n# each with 5,000 items.\ndatasets['Weibull 5k'] = {'test_0': {'capacity': 100, 'num_items': 5000,\n 'items': [48, 66, 48, 32, 72, 37, 41, 21, 58, 35, 18, 53, 52, 42, 51, 30, 42, 44,\n 58, 62, 28, 20, 27, 53, 59, 56, 46, 60, 21, 49, 29, 58, 31, 47, 34, 41,\n 28, 49, 22, 37, 31, 27, 50, 46, 39, 52, 40, 41, 31, 57, 53, 57, 35, 39,\n 38, 40, 34, 22, 30, 48, 34, 34, 48, 53, 23, 57, 50, 67, 18, 40, 38, 38,\n 42, 53, 38, 37, 53, 62, 22, 51, 34, 51, 24, 92, 60, 29, 39, 49, 24, 33,\n 67, 65, 62, 57, 60, 29, 53, 29, 54, 52, 37, 59, 55, 69, 20, 41, 47, 44,\n 36, 48, 61, 33, 53, 36, 47, 38, 39, 35, 41, 31, 42, 41, 45, 49, 25, 20,\n 71, 61, 35, 33, 42, 11, 39, 68, 43, 30, 51, 31, 68, 29, 40, 45, 41, 23,\n 46, 65, 37, 60, 45, 38, 28, 45, 42, 30, 39, 59, 36, 60, 58, 32, 49, 19,\n 55, 46, 55, 53, 46, 32, 56, 29, 23, 22, 26, 19, 37, 24, 50, 44, 33, 27,\n 26, 34, 38, 21, 58, 48, 66, 37, 40, 10, 37, 27, 56, 30, 49, 19, 52, 17,\n 41, 29, 38, 53, 21, 36, 37, 23, 35, 26, 25, 33, 11, 34, 18, 69, 36, 50,\n 40, 19, 65, 51, 53, 35, 35, 45, 21, 27, 60, 35, 56, 14, 65, 40, 24, 39,\n 49, 85, 54, 32, 28, 27, 9, 28, 44, 47, 65, 59, 23, 46, 36, 46, 18, 20,\n 20, 36, 50, 71, 57, 63, 31, 35, 47, 35, 35, 41, 48, 19, 53, 69, 26, 43,\n 45, 27, 52, 19, 49, 45, 29, 32, 29, 22, 52, 15, 47, 39, 26, 41, 27, 31,\n 63, 50, 21, 30, 21, 42, 43, 21, 71, 21, 34, 29, 80, 41, 37, 51, 35, 33,\n 45, 26, 44, 30, 41, 22, 55, 26, 43, 35, 15, 31, 32, 53, 36, 33, 25, 19,\n 29, 64, 56, 17, 30, 13, 66, 19, 39, 51, 38, 39, 54, 37, 37, 17, 8, 45,\n 58, 19, 48, 51, 41, 53, 69, 33, 37, 29, 25, 41, 54, 51, 26, 29, 66, 60,\n 36, 33, 17, 31, 48, 73, 16, 26, 46, 25, 25, 33, 57, 49, 28, 62, 44, 22,\n 19, 65, 25, 60, 39, 39, 36, 45, 40, 45, 43, 28, 45, 28, 54, 44, 54, 32,\n 62, 67, 34, 31, 29, 47, 38, 35, 69, 57, 40, 20, 37, 27, 56, 25, 57, 54,\n 36, 45, 56, 49, 35, 77, 71, 53, 46, 41, 25, 50, 50, 44, 79, 52, 19, 44,\n 43, 36, 40, 36, 36, 35, 51, 35, 41, 67, 47, 46, 13, 53, 56, 37, 41, 46,\n 36, 70, 29, 18, 35, 59, 7, 51, 36, 52, 24, 40, 21, 74, 21, 23, 28, 47,\n 43, 40, 50, 61, 65, 17, 59, 60, 52, 53, 19, 51, 63, 59, 25, 42, 50, 50,\n 60, 61, 27, 37, 25, 55, 69, 45, 51, 36, 47, 20, 56, 39, 20, 43, 50, 34,\n 42, 37, 60, 48, 18, 41, 42, 35, 34, 46, 20, 61, 57, 25, 42, 72, 16, 39,\n 29, 64, 37, 44, 39, 32, 47, 61, 23, 41, 21, 38, 33, 67, 60, 54, 66, 51,\n 70, 39, 34, 47, 16, 38, 48, 54, 15, 34, 34, 14, 22, 25, 32, 11, 19, 44,\n 32, 36, 43, 20, 55, 46, 38, 62, 43, 35, 19, 47, 31, 17, 42, 31, 39, 49,\n 37, 53, 36, 64, 29, 19, 42, 47, 45, 9, 45, 52, 59, 35, 67, 25, 27, 55,\n 44, 47, 38, 17, 24, 61, 68, 35, 36, 18, 23, 50, 20, 36, 35, 48, 32, 29,\n 62, 23, 32, 36, 25, 15, 57, 50, 43, 43, 30, 24, 56, 52, 65, 17, 48, 29,\n 64, 52, 20, 45, 60, 54, 38, 57, 27, 32, 20, 44, 18, 18, 32, 38, 36, 39,\n 17, 41, 42, 67, 39, 21, 30, 61, 40, 43, 31, 16, 40, 41, 38, 38, 11, 43,\n 40, 17, 41, 65, 48, 42, 47, 24, 86, 26, 29, 48, 34, 19, 55, 65, 53, 68,\n 43, 41, 28, 50, 49, 15, 42, 26, 14, 45, 26, 61, 54, 25, 44, 28, 43, 43,\n 18, 44, 21, 52, 47, 38, 32, 55, 54, 24, 75, 38, 53, 24, 24, 39, 63, 32,\n 47, 32, 67, 32, 43, 25, 52, 47, 48, 50, 56, 18, 48, 64, 66, 37, 36, 42,\n 30, 37, 53, 32, 73, 40, 55, 30, 38, 34, 60, 39, 22, 43, 32, 13, 44, 41,\n 23, 48, 28, 42, 22, 34, 49, 55, 27, 34, 38, 43, 35, 71, 61, 44, 32, 22,\n 27, 82, 38, 50, 30, 54, 29, 48, 45, 45, 42, 64, 36, 44, 26, 52, 12, 32,\n 46, 50, 23, 56, 54, 23, 47, 46, 38, 60, 45, 38, 58, 48, 53, 37, 34, 45,\n 25, 38, 32, 11, 46, 38, 32, 42, 58, 59, 12, 50, 49, 44, 46, 37, 53, 58,\n 47, 34, 45, 39, 58, 31, 29, 36, 38, 36, 49, 56, 45, 34, 28, 7, 31, 42,\n 15, 49, 51, 47, 26, 20, 52, 26, 50, 32, 34, 33, 51, 73, 17, 45, 40, 35,\n 24, 30, 46, 42, 21, 11, 49, 32, 67, 50, 47, 54, 44, 57, 55, 36, 51, 37,\n 26, 35, 20, 42, 32, 46, 30, 33, 44, 67, 23, 47, 45, 39, 14, 37, 41, 29,\n 59, 53, 21, 15, 49, 37, 56, 19, 28, 48, 41, 30, 27, 32, 10, 83, 58, 22,\n 40, 46, 52, 34, 34, 43, 22, 17, 28, 67, 58, 35, 33, 18, 11, 44, 35, 20,\n 60, 50, 44, 23, 49, 29, 44, 66, 37, 44, 15, 62, 27, 41, 52, 32, 44, 28,\n 11, 32, 28, 72, 35, 21, 54, 42, 57, 37, 26, 37, 43, 49, 24, 57, 37, 37,\n 41, 19, 27, 40, 49, 50, 14, 59, 61, 34, 35, 53, 33, 36, 31, 42, 32, 60,\n 20, 46, 41, 31, 12, 59, 22, 60, 53, 22, 58, 19, 27, 23, 37, 32, 42, 58,\n 24, 38, 29, 26, 57, 17, 34, 34, 17, 35, 61, 48, 45, 31, 38, 22, 47, 38,\n 25, 47, 47, 43, 38, 46, 52, 45, 39, 64, 21, 35, 31, 32, 44, 46, 31, 75,\n 48, 23, 47, 31, 34, 22, 24, 50, 28, 32, 23, 49, 53, 51, 30, 70, 36, 28,\n 54, 14, 61, 61, 37, 24, 38, 34, 43, 26, 38, 44, 55, 42, 33, 35, 29, 28,\n 18, 19, 51, 39, 28, 54, 43, 43, 41, 27, 29, 17, 14, 44, 46, 77, 55, 34,\n 61, 45, 29, 24, 32, 38, 15, 72, 9, 19, 25, 59, 21, 53, 13, 42, 38, 29,\n 30, 39, 59, 41, 13, 38, 46, 21, 49, 41, 28, 19, 61, 24, 15, 52, 34, 23,\n 55, 31, 36, 54, 45, 66, 69, 37, 54, 69, 50, 62, 15, 49, 29, 56, 25, 64,\n 30, 34, 25, 23, 46, 52, 59, 40, 58, 59, 58, 57, 21, 25, 44, 28, 41, 44,\n 13, 17, 81, 29, 68, 61, 42, 38, 66, 10, 57, 49, 63, 31, 67, 63, 20, 65,\n 35, 14, 73, 55, 37, 69, 46, 48, 24, 39, 42, 45, 27, 48, 43, 24, 30, 41,\n 24, 43, 49, 45, 61, 56, 43, 39, 59, 61, 36, 22, 54, 38, 73, 44, 26, 49,\n 50, 44, 44, 30, 26, 16, 46, 29, 25, 54, 26, 52, 63, 61, 23, 23, 44, 31,\n 48, 27, 32, 28, 33, 46, 41, 35, 29, 56, 62, 81, 58, 67, 7, 46, 79, 36,\n 18, 37, 48, 34, 48, 56, 38, 18, 27, 33, 53, 21, 37, 43, 31, 50, 27, 39,\n 25, 41, 58, 24, 46, 43, 62, 28, 51, 20, 65, 57, 70, 15, 31, 73, 13, 32,\n 64, 32, 17, 60, 37, 35, 27, 49, 38, 42, 37, 49, 26, 51, 66, 19, 20, 63,\n 44, 21, 40, 44, 65, 44, 50, 51, 26, 45, 53, 46, 35, 65, 26, 62, 37, 24,\n 64, 13, 60, 54, 46, 37, 31, 48, 29, 18, 31, 12, 45, 31, 29, 31, 32, 35,\n 40, 40, 26, 41, 55, 21, 14, 47, 54, 41, 64, 13, 17, 68, 28, 11, 47, 65,\n 35, 25, 56, 68, 48, 25, 67, 43, 38, 10, 56, 31, 69, 42, 61, 45, 40, 54,\n 34, 32, 48, 65, 52, 58, 40, 28, 21, 20, 53, 41, 28, 45, 25, 69, 47, 38,\n 62, 30, 47, 16, 35, 61, 29, 29, 32, 76, 51, 50, 38, 58, 33, 48, 48, 48,\n 19, 22, 66, 42, 53, 35, 17, 30, 27, 45, 24, 52, 14, 32, 63, 44, 34, 31,\n 72, 28, 43, 17, 40, 58, 54, 25, 38, 41, 46, 22, 34, 26, 56, 31, 29, 19,\n 56, 46, 38, 57, 40, 30, 46, 36, 61, 34, 39, 52, 49, 8, 56, 49, 21, 30,\n 23, 34, 43, 50, 49, 70, 53, 19, 47, 48, 47, 22, 22, 49, 33, 53, 28, 39,\n 55, 32, 41, 31, 24, 30, 32, 42, 33, 31, 54, 38, 22, 63, 42, 29, 54, 50,\n 56, 39, 49, 38, 40, 33, 42, 61, 59, 22, 26, 41, 19, 71, 54, 46, 31, 47,\n 45, 21, 53, 40, 31, 67, 45, 66, 37, 21, 38, 45, 34, 41, 41, 45, 32, 46,\n 66, 60, 43, 41, 31, 56, 64, 39, 65, 19, 70, 38, 66, 28, 35, 26, 35, 20,\n 60, 31, 52, 30, 28, 26, 34, 50, 50, 57, 33, 48, 18, 28, 20, 68, 43, 41,\n 19, 36, 58, 56, 27, 48, 14, 45, 52, 31, 65, 40, 31, 19, 58, 43, 67, 16,\n 55, 60, 25, 43, 44, 29, 76, 50, 32, 55, 21, 37, 51, 64, 60, 41, 22, 31,\n 37, 30, 60, 33, 57, 40, 32, 10, 36, 33, 75, 47, 18, 64, 50, 32, 29, 41,\n 17, 38, 64, 58, 57, 44, 29, 50, 21, 66, 42, 40, 20, 39, 25, 44, 42, 18,\n 57, 46, 29, 42, 11, 17, 49, 38, 22, 3, 43, 34, 38, 21, 65, 44, 24, 28,\n 58, 51, 73, 34, 35, 36, 64, 59, 54, 16, 22, 39, 35, 18, 40, 50, 29, 43,\n 41, 11, 27, 49, 86, 49, 27, 44, 28, 19, 31, 31, 78, 23, 25, 44, 17, 34,\n 36, 22, 39, 6, 31, 41, 34, 37, 35, 36, 62, 65, 18, 25, 42, 39, 61, 41,\n 61, 55, 58, 32, 56, 44, 37, 35, 39, 41, 39, 58, 59, 45, 42, 50, 46, 76,\n 62, 27, 50, 50, 66, 30, 59, 34, 9, 32, 12, 30, 47, 32, 30, 48, 41, 33,\n 71, 39, 47, 49, 20, 28, 67, 29, 35, 28, 17, 45, 72, 48, 26, 52, 26, 71,\n 34, 60, 27, 64, 20, 54, 34, 57, 38, 68, 38, 45, 54, 21, 39, 41, 13, 39,\n 31, 22, 53, 44, 52, 18, 41, 22, 34, 30, 29, 12, 38, 62, 51, 61, 11, 35,\n 46, 33, 49, 9, 38, 50, 35, 38, 52, 42, 68, 48, 69, 50, 56, 40, 55, 34,\n 66, 25, 34, 25, 28, 53, 51, 40, 51, 77, 26, 29, 42, 36, 44, 43, 39, 62,\n 54, 42, 34, 7, 59, 65, 21, 39, 51, 57, 25, 28, 47, 37, 33, 66, 47, 31,\n 52, 46, 25, 51, 41, 41, 24, 47, 41, 47, 42, 65, 56, 40, 39, 68, 9, 50,\n 53, 27, 59, 49, 38, 38, 52, 29, 15, 46, 40, 47, 40, 45, 21, 36, 31, 27,\n 35, 48, 50, 54, 21, 32, 47, 29, 24, 35, 37, 38, 40, 51, 52, 56, 29, 17,\n 40, 51, 41, 28, 16, 55, 38, 25, 43, 43, 58, 55, 63, 46, 24, 26, 35, 48,\n 56, 20, 48, 54, 43, 24, 48, 29, 43, 24, 1, 44, 45, 27, 62, 41, 30, 32,\n 69, 39, 45, 45, 42, 22, 43, 25, 7, 32, 38, 49, 42, 50, 53, 61, 45, 53,\n 52, 50, 40, 56, 31, 47, 27, 46, 51, 18, 35, 23, 25, 35, 37, 49, 38, 44,\n 36, 35, 54, 28, 59, 48, 34, 42, 57, 39, 44, 49, 42, 47, 40, 37, 35, 59,\n 3, 55, 43, 32, 60, 17, 15, 39, 34, 28, 52, 21, 39, 32, 61, 50, 57, 46,\n 58, 52, 49, 43, 34, 30, 25, 69, 58, 28, 34, 40, 25, 40, 25, 42, 42, 35,\n 42, 30, 33, 19, 38, 49, 65, 45, 57, 6, 32, 45, 48, 73, 26, 47, 28, 66,\n 36, 38, 44, 53, 29, 48, 40, 59, 47, 53, 43, 39, 55, 59, 42, 33, 45, 47,\n 30, 30, 30, 40, 57, 63, 48, 50, 69, 56, 40, 37, 31, 55, 75, 47, 18, 34,\n 35, 46, 19, 20, 25, 47, 13, 32, 57, 40, 24, 38, 16, 46, 9, 24, 44, 51,\n 46, 25, 54, 17, 33, 41, 21, 50, 45, 48, 33, 32, 35, 33, 43, 18, 56, 61,\n 83, 48, 21, 36, 73, 34, 32, 38, 19, 55, 37, 62, 61, 47, 74, 47, 41, 31,\n 47, 52, 81, 54, 42, 47, 45, 61, 25, 36, 57, 27, 42, 61, 35, 52, 87, 61,\n 21, 20, 28, 50, 20, 23, 57, 67, 64, 17, 38, 42, 18, 47, 34, 64, 22, 41,\n 44, 38, 19, 12, 31, 36, 45, 49, 54, 40, 29, 26, 33, 39, 36, 43, 32, 34,\n 32, 13, 37, 45, 67, 36, 43, 53, 19, 53, 33, 29, 36, 47, 45, 47, 21, 34,\n 23, 43, 26, 16, 35, 48, 31, 47, 53, 34, 31, 65, 50, 47, 18, 8, 38, 48,\n 40, 27, 46, 55, 22, 23, 62, 29, 50, 20, 64, 51, 46, 49, 40, 27, 47, 31,\n 33, 28, 42, 52, 41, 33, 25, 33, 27, 23, 52, 43, 47, 7, 14, 41, 50, 33,\n 38, 20, 49, 39, 55, 47, 43, 22, 24, 63, 29, 65, 24, 27, 21, 57, 34, 42,\n 29, 28, 74, 31, 25, 45, 26, 10, 45, 5, 35, 15, 33, 18, 27, 58, 51, 48,\n 18, 56, 34, 44, 48, 36, 49, 87, 48, 57, 35, 23, 51, 24, 33, 34, 39, 42,\n 20, 37, 47, 52, 31, 27, 12, 41, 37, 80, 33, 61, 79, 71, 47, 70, 60, 60,\n 29, 42, 50, 27, 32, 57, 41, 27, 31, 62, 37, 30, 53, 46, 40, 33, 62, 39,\n 31, 74, 25, 55, 36, 71, 59, 28, 8, 28, 23, 53, 13, 31, 10, 56, 50, 43,\n 22, 53, 63, 33, 34, 50, 30, 34, 38, 36, 29, 31, 22, 42, 74, 37, 50, 39,\n 42, 29, 62, 38, 16, 58, 18, 49, 58, 50, 23, 36, 36, 53, 47, 57, 77, 45,\n 44, 11, 32, 22, 48, 49, 25, 61, 59, 69, 21, 44, 69, 45, 41, 22, 44, 40,\n 53, 43, 27, 46, 21, 47, 26, 24, 35, 38, 46, 59, 66, 48, 45, 42, 36, 47,\n 45, 18, 49, 5, 27, 33, 58, 78, 16, 23, 19, 34, 16, 46, 48, 36, 28, 56,\n 49, 53, 43, 27, 42, 41, 39, 23, 24, 20, 30, 12, 68, 30, 59, 29, 17, 29,\n 39, 51, 47, 59, 50, 52, 23, 18, 78, 67, 16, 50, 49, 19, 55, 31, 47, 50,\n 66, 45, 35, 33, 39, 42, 42, 49, 42, 62, 46, 56, 31, 43, 36, 38, 34, 61,\n 50, 55, 42, 34, 31, 38, 21, 52, 33, 65, 46, 26, 55, 35, 19, 60, 69, 47,\n 24, 22, 45, 40, 43, 66, 49, 32, 21, 15, 51, 50, 20, 69, 15, 36, 31, 49,\n 18, 41, 21, 48, 18, 47, 11, 46, 45, 19, 60, 53, 28, 15, 24, 47, 49, 40,\n 40, 65, 56, 54, 61, 61, 25, 39, 61, 30, 47, 49, 31, 27, 23, 51, 37, 47,\n 46, 36, 19, 45, 22, 46, 31, 48, 8, 44, 20, 15, 12, 52, 30, 24, 40, 19,\n 54, 70, 58, 55, 25, 48, 49, 49, 23, 60, 23, 44, 39, 28, 57, 55, 58, 44,\n 27, 36, 53, 32, 18, 36, 58, 41, 25, 43, 46, 18, 40, 35, 55, 46, 37, 23,\n 16, 56, 26, 32, 34, 61, 68, 48, 43, 35, 40, 51, 30, 22, 41, 25, 43, 63,\n 44, 50, 27, 38, 32, 30, 20, 46, 63, 6, 50, 32, 47, 59, 29, 48, 30, 72,\n 19, 41, 34, 21, 24, 29, 43, 46, 36, 68, 37, 41, 66, 52, 19, 50, 36, 26,\n 26, 41, 19, 48, 71, 37, 72, 22, 42, 54, 33, 20, 63, 56, 30, 44, 44, 49,\n 60, 45, 63, 14, 44, 40, 66, 36, 22, 46, 13, 42, 27, 9, 63, 48, 73, 38,\n 32, 9, 28, 60, 53, 50, 39, 36, 51, 37, 59, 49, 53, 37, 44, 48, 42, 29,\n 65, 37, 54, 35, 22, 10, 40, 36, 35, 25, 43, 59, 4, 33, 18, 23, 50, 33,\n 60, 48, 27, 18, 47, 55, 51, 63, 45, 56, 50, 57, 44, 22, 55, 34, 48, 43,\n 39, 27, 41, 31, 33, 21, 27, 34, 29, 37, 27, 48, 44, 55, 55, 33, 51, 52,\n 70, 51, 29, 71, 42, 51, 49, 27, 35, 36, 38, 43, 38, 59, 50, 52, 33, 54,\n 62, 28, 41, 23, 44, 25, 21, 61, 54, 35, 19, 54, 31, 38, 21, 50, 46, 26,\n 47, 46, 32, 48, 48, 39, 37, 24, 33, 19, 51, 34, 51, 27, 56, 35, 34, 33,\n 57, 33, 10, 48, 30, 49, 61, 37, 70, 40, 35, 35, 30, 27, 52, 38, 52, 57,\n 36, 43, 15, 27, 50, 55, 14, 37, 40, 71, 69, 26, 43, 31, 47, 43, 41, 44,\n 24, 17, 29, 64, 26, 27, 82, 17, 35, 53, 16, 22, 20, 34, 52, 32, 50, 51,\n 17, 28, 34, 42, 58, 23, 28, 30, 69, 37, 57, 52, 41, 29, 40, 58, 63, 66,\n 24, 39, 88, 44, 50, 31, 15, 51, 68, 24, 34, 34, 37, 51, 27, 64, 34, 50,\n 40, 43, 42, 47, 39, 30, 23, 23, 23, 51, 39, 27, 46, 64, 49, 50, 15, 15,\n 31, 29, 33, 50, 52, 24, 45, 41, 52, 61, 30, 40, 34, 51, 46, 36, 17, 50,\n 27, 47, 52, 54, 23, 64, 48, 40, 57, 11, 49, 29, 23, 62, 43, 66, 24, 16,\n 57, 10, 16, 20, 57, 23, 52, 34, 46, 29, 57, 48, 37, 45, 13, 47, 41, 42,\n 45, 65, 18, 50, 43, 40, 52, 49, 52, 29, 43, 37, 57, 79, 45, 51, 68, 33,\n 36, 30, 42, 37, 66, 40, 42, 44, 34, 59, 36, 34, 26, 44, 32, 36, 53, 44,\n 50, 24, 32, 13, 33, 23, 33, 35, 32, 49, 38, 54, 17, 39, 20, 45, 77, 53,\n 69, 22, 56, 50, 10, 44, 38, 56, 62, 35, 47, 65, 37, 58, 38, 31, 57, 22,\n 46, 19, 21, 55, 53, 39, 29, 45, 26, 49, 40, 41, 34, 36, 10, 51, 49, 40,\n 34, 16, 51, 26, 51, 24, 36, 42, 45, 56, 30, 36, 42, 22, 27, 32, 45, 50,\n 43, 61, 33, 56, 38, 38, 48, 37, 31, 14, 37, 17, 13, 37, 55, 13, 56, 34,\n 43, 33, 23, 29, 48, 51, 32, 18, 41, 32, 37, 53, 36, 49, 22, 38, 40, 28,\n 62, 43, 42, 40, 31, 36, 58, 29, 44, 35, 46, 37, 42, 43, 39, 53, 37, 35,\n 31, 42, 20, 24, 52, 37, 42, 66, 43, 12, 61, 17, 46, 34, 14, 45, 22, 22,\n 44, 15, 29, 51, 43, 50, 31, 30, 42, 45, 39, 55, 35, 50, 45, 66, 43, 54,\n 47, 45, 30, 37, 39, 24, 26, 34, 47, 42, 38, 64, 32, 28, 32, 33, 32, 36,\n 36, 27, 23, 62, 29, 62, 48, 39, 27, 58, 33, 35, 58, 50, 29, 24, 34, 69,\n 28, 19, 29, 26, 28, 28, 46, 79, 40, 61, 81, 66, 63, 68, 47, 24, 52, 17,\n 40, 22, 19, 20, 20, 44, 33, 66, 39, 32, 45, 17, 14, 44, 45, 34, 47, 58,\n 40, 64, 35, 31, 31, 39, 28, 38, 48, 43, 23, 22, 35, 45, 37, 41, 40, 20,\n 22, 33, 11, 45, 44, 58, 35, 48, 38, 53, 50, 27, 34, 23, 40, 39, 55, 70,\n 40, 17, 51, 28, 22, 34, 24, 21, 61, 50, 44, 64, 26, 58, 23, 63, 57, 40,\n 25, 27, 21, 37, 37, 46, 36, 41, 35, 73, 33, 26, 15, 14, 8, 43, 57, 29,\n 38, 49, 22, 34, 70, 41, 42, 37, 35, 28, 25, 37, 25, 29, 39, 42, 26, 47,\n 67, 11, 58, 50, 44, 21, 44, 31, 62, 30, 25, 35, 58, 40, 79, 19, 35, 54,\n 23, 55, 30, 51, 47, 33, 65, 36, 26, 33, 37, 33, 54, 31, 61, 59, 45, 49,\n 58, 31, 6, 24, 9, 41, 68, 35, 43, 64, 34, 76, 42, 43, 39, 60, 37, 38, 14,\n 40, 42, 65, 76, 56, 67, 43, 39, 45, 33, 21, 21, 41, 15, 9, 15, 49, 57,\n 58, 46, 58, 68, 21, 79, 51, 70, 19, 26, 37, 42, 51, 32, 16, 32, 15, 57,\n 36, 72, 43, 29, 28, 57, 42, 54, 19, 28, 46, 34, 47, 43, 57, 60, 54, 34,\n 41, 60, 30, 58, 48, 37, 48, 56, 64, 63, 57, 30, 44, 60, 48, 50, 32, 68,\n 52, 59, 69, 40, 34, 51, 79, 21, 47, 60, 65, 27, 50, 22, 38, 40, 41, 7,\n 59, 59, 24, 24, 55, 48, 43, 41, 37, 56, 55, 26, 51, 35, 33, 48, 33, 42,\n 40, 41, 52, 37, 14, 67, 34, 3, 14, 82, 58, 32, 46, 49, 59, 44, 18, 27,\n 34, 49, 63, 49, 16, 26, 61, 38, 42, 12, 13, 54, 18, 33, 38, 53, 38, 38,\n 34, 49, 40, 42, 26, 18, 28, 33, 30, 45, 47, 12, 60, 37, 73, 61, 31, 6,\n 37, 27, 21, 26, 39, 37, 30, 35, 60, 38, 49, 32, 74, 30, 43, 74, 29, 34,\n 51, 51, 33, 29, 41, 36, 33, 65, 49, 32, 56, 22, 41, 53, 59, 27, 27, 38,\n 35, 37, 42, 63, 45, 35, 61, 53, 37, 57, 44, 32, 24, 40, 40, 37, 53, 48,\n 18, 40, 62, 49, 65, 16, 24, 64, 55, 37, 50, 60, 49, 41, 70, 50, 41, 26,\n 46, 41, 30, 43, 40, 32, 41, 31, 31, 20, 41, 28, 22, 59, 36, 38, 42, 38,\n 16, 59, 52, 49, 26, 34, 43, 24, 20, 48, 39, 14, 25, 24, 29, 43, 37, 50,\n 20, 43, 71, 53, 39, 52, 29, 35, 55, 43, 30, 70, 16, 49, 59, 44, 47, 34,\n 56, 53, 29, 41, 46, 40, 39, 28, 23, 26, 36, 61, 41, 38, 46, 49, 34, 36,\n 14, 34, 48, 21, 33, 22, 35, 51, 35, 14, 54, 53, 41, 52, 48, 39, 36, 44,\n 36, 41, 45, 56, 32, 21, 64, 48, 24, 32, 29, 33, 34, 38, 41, 54, 33, 27,\n 29, 59, 43, 37, 27, 50, 25, 38, 23, 61, 47, 48, 60, 45, 30, 14, 35, 57,\n 39, 29, 40, 32, 40, 43, 47, 33, 47, 42, 34, 50, 23, 24, 26, 31, 28, 49,\n 30, 56, 9, 30, 30, 45, 17, 54, 58, 16, 17, 39, 32, 53, 38, 23, 46, 33,\n 12, 39, 31, 44, 46, 62, 35, 68, 45, 54, 47, 30, 50, 43, 60, 44, 12, 50,\n 28, 60, 66, 45, 38, 50, 31, 26, 40, 25, 25, 31, 54, 50, 53, 23, 18, 54,\n 53, 49, 66, 52, 12, 28, 60, 25, 54, 72, 48, 33, 46, 44, 44, 37, 54, 63,\n 33, 41, 32, 43, 35, 79, 52, 41, 68, 22, 53, 29, 31, 43, 43, 63, 37, 44,\n 43, 17, 36, 34, 58, 54, 54, 26, 27, 26, 49, 22, 51, 39, 57, 31, 32, 8,\n 44, 16, 23, 30, 51, 27, 54, 37, 32, 55, 41, 25, 39, 54, 15, 22, 47, 34,\n 61, 27, 53, 45, 44, 35, 41, 52, 42, 39, 45, 65, 61, 67, 43, 40, 38, 43,\n 44, 31, 35, 63, 57, 47, 28, 21, 36, 57, 54, 52, 32, 53, 23, 62, 22, 33,\n 32, 48, 39, 43, 20, 49, 51, 54, 46, 31, 41, 12, 49, 20, 36, 37, 62, 32,\n 33, 31, 34, 52, 35, 62, 24, 50, 52, 25, 8, 31, 22, 60, 52, 33, 57, 63,\n 59, 42, 28, 50, 25, 35, 56, 70, 65, 64, 46, 55, 16, 21, 44, 51, 39, 62,\n 46, 50, 53, 26, 24, 32, 26, 62, 17, 36, 55, 42, 50, 44, 43, 45, 22, 19,\n 62, 18, 35, 56, 27, 47, 42, 47, 7, 42, 29, 49, 50, 52, 42, 17, 53, 41,\n 53, 42, 45, 54, 63, 56, 23, 57, 45, 34, 29, 34, 14, 38, 42, 38, 43, 57,\n 32, 23, 42, 25, 16, 28, 39, 30, 54, 36, 32, 52, 83, 80, 35, 19, 23, 23,\n 34, 20, 46, 20, 57, 52, 34, 50, 48, 40, 51, 51, 65, 37, 8, 43, 40, 35,\n 38, 61, 22, 41, 56, 62, 30, 51, 29, 29, 51, 35, 39, 39, 28, 18, 53, 22,\n 47, 5, 30, 34, 30, 71, 57, 44, 58, 43, 56, 36, 38, 24, 33, 43, 28, 51,\n 36, 43, 68, 37, 49, 41, 9, 33, 42, 68, 45, 24, 50, 67, 47, 66, 50, 43,\n 15, 69, 42, 25, 48, 65, 37, 42, 65, 31, 45, 27, 34, 41, 68, 40, 21, 33,\n 19, 51, 39, 15, 19, 48, 53, 40, 83, 8, 50, 59, 47, 52, 60, 43, 57, 37,\n 49, 45, 52, 57, 10, 53, 25, 32, 58, 40, 33, 44, 32, 36, 44, 39, 19, 40,\n 54, 21, 48, 51, 37, 58, 14, 40, 55, 74, 37, 33, 30, 39, 72, 40, 34, 15,\n 34, 60, 55, 42, 38, 44, 51, 43, 12, 44, 43, 46, 15, 73, 37, 25, 9, 67,\n 30, 39, 59, 36, 19, 57, 31, 29, 36, 23, 13, 32, 50, 25, 39, 57, 48, 28,\n 45, 52, 31, 37, 53, 33, 47, 24, 33, 36, 62, 38, 29, 80, 27, 54, 42, 27,\n 61, 48, 13, 61, 53, 46, 19, 28, 42, 49, 43, 50, 34, 35, 17, 24, 44, 57,\n 17, 15, 21, 45, 25, 40, 38, 27, 31, 35, 46, 23, 25, 31, 61, 19, 38, 50,\n 29, 34, 36, 55, 34, 48, 68, 37, 37, 80, 26, 31, 23, 52, 26, 42, 20, 22,\n 61, 20, 42, 28, 34, 51, 38, 71, 60, 39, 39, 27, 34, 37, 14, 50, 38, 58,\n 55, 43, 20, 33, 44, 39, 32, 12, 35, 36, 53, 23, 23, 29, 14, 45, 53, 53,\n 61, 22, 78, 39, 46, 40, 60, 64, 39, 32, 32, 43, 13, 40, 15, 36, 55, 67,\n 39, 15, 29, 29, 56, 44, 66, 43, 50, 31, 40, 37, 54, 39, 42, 40, 25, 17,\n 32, 38, 59, 38, 26, 28, 7, 28, 60, 24, 36, 41, 45, 41, 22, 43, 40, 26,\n 24, 44, 39, 21, 38, 44, 44, 51, 25, 65, 59, 34, 27, 47, 43, 45, 14, 42,\n 20, 31, 16, 31, 35, 36, 45, 52, 48, 32, 40, 58, 27, 30, 23, 53, 25, 48,\n 35, 75, 13, 36, 38, 39, 49, 69, 20, 41, 58, 26, 45, 48, 17, 29, 49, 38,\n 27, 45, 17, 40, 68, 16, 17, 41, 50, 26, 20, 28, 36, 23, 27, 39, 46, 25,\n 24, 47, 60, 44, 47, 29, 25, 58, 36, 39, 53, 33, 35, 48, 41, 39, 34, 16,\n 64, 50, 45, 53, 16, 37, 59, 51, 50, 30, 59, 20, 15, 39, 65, 40, 25, 36,\n 53, 40, 57, 42, 48, 66, 26, 51, 25, 41, 75, 54, 34, 52, 15, 56, 41, 49,\n 42, 26, 26, 33, 64, 46, 45, 14, 33, 60, 26, 59, 58, 53, 27, 51, 15, 41,\n 10, 33, 22, 31, 48, 21, 51, 27, 18, 37, 49, 51, 37, 68, 21, 35, 69, 42,\n 29, 41, 34, 64, 15, 28, 35, 38, 50, 50, 34, 62, 59, 27, 53, 23, 43, 48,\n 33, 15, 55, 40, 54, 37, 34, 31, 26, 50, 28, 44, 22, 59, 43, 40, 47, 34,\n 61, 34, 44, 42, 54, 57, 50, 46, 37, 21, 26, 39, 61, 33, 37, 45, 28, 44,\n 20, 50, 24, 40, 36, 44, 44, 44, 22, 73, 49, 18, 16, 39, 61, 31, 48, 20,\n 27, 59, 31, 45, 43, 32, 46, 29, 46, 16, 28, 35, 45, 42, 32, 29, 69, 35,\n 43, 25, 56, 53, 31, 34, 21, 60, 30, 59, 41, 42, 59, 49, 37, 30, 28, 61,\n 17, 52, 23, 33, 34, 36, 19, 45, 46, 27, 25, 33, 38, 50, 24, 19, 34, 51,\n 35, 38, 33, 36, 34, 25, 34, 33, 39, 20, 56, 30, 26, 27, 42, 65, 42, 55,\n 38, 38, 43, 45, 43, 9, 51, 58, 34, 39, 64, 42, 20, 47, 26, 26, 22, 47,\n 46, 41, 49, 19, 46, 73, 41, 32, 19, 57, 65, 22, 17, 26, 26, 46, 66, 47,\n 61, 70, 38, 42, 56, 34, 36, 52, 34, 59, 66, 69, 58, 29, 48, 21, 48, 50,\n 28, 42, 30, 55, 42, 39, 69, 50, 76, 55, 54, 40, 58, 39, 54, 31, 39, 50,\n 32, 49, 45, 61, 39, 38, 45, 49, 52, 43, 27, 19, 59, 35, 23, 55, 34, 32,\n 61, 22, 33, 51, 23, 17, 52, 62, 59, 54, 48, 24, 27, 22, 58, 28, 29, 7,\n 33, 60, 50, 56, 10, 11, 42, 35, 56, 53, 18, 37, 24, 70, 28, 35, 35, 13,\n 23, 46, 19, 29, 52, 49, 55, 45, 28, 47, 37, 40, 42, 67, 28, 37, 16, 27,\n 43, 41, 40, 54, 60, 38, 45, 65, 21, 33, 55, 34, 44, 29, 45, 34, 65, 60,\n 10, 44, 28, 21, 53, 54, 48, 41, 34, 41, 32, 42, 18, 31, 22, 45, 54, 44,\n 49, 22, 37, 41, 59, 32, 35, 37, 38, 66, 49, 53, 30, 31, 18, 49, 14, 56,\n 40, 27, 18, 16, 16, 31, 66, 46, 41, 21, 54, 51, 51, 42, 43, 31, 36, 32,\n 17, 35, 30, 29, 38, 47, 32, 13, 57, 45, 35, 60, 38]},\n 'test_1': {'capacity': 100, 'num_items': 5000,\n 'items': [42, 57, 41, 42, 43, 30, 26, 21, 42, 24, 37, 52, 50, 32, 76, 58, 69, 35,\n 30, 42, 40, 28, 63, 60, 42, 46, 38, 39, 45, 43, 53, 72, 26, 41, 39, 19,\n 63, 43, 32, 29, 48, 33, 29, 17, 44, 13, 57, 48, 12, 60, 51, 27, 55, 40,\n 22, 63, 37, 53, 34, 25, 41, 54, 36, 46, 43, 44, 41, 42, 20, 35, 31, 32,\n 72, 36, 20, 26, 26, 65, 48, 31, 71, 43, 46, 36, 33, 52, 32, 35, 56, 35,\n 29, 36, 61, 50, 66, 36, 29, 13, 60, 43, 40, 66, 49, 28, 48, 23, 35, 55,\n 84, 50, 50, 39, 33, 45, 42, 40, 27, 26, 21, 54, 30, 59, 18, 41, 52, 8,\n 19, 64, 41, 38, 50, 53, 65, 20, 15, 18, 36, 27, 27, 30, 43, 10, 33, 55,\n 26, 28, 48, 50, 36, 43, 39, 42, 48, 8, 46, 21, 15, 59, 33, 41, 40, 46,\n 44, 33, 42, 30, 32, 57, 30, 32, 30, 30, 41, 77, 49, 14, 54, 56, 68, 53,\n 24, 31, 29, 43, 22, 16, 26, 47, 18, 46, 29, 13, 47, 33, 44, 40, 60, 22,\n 66, 55, 37, 41, 37, 32, 37, 53, 77, 42, 28, 35, 32, 28, 27, 63, 36, 38,\n 61, 40, 17, 66, 53, 45, 55, 24, 3, 45, 53, 43, 59, 70, 45, 33, 68, 44,\n 39, 64, 56, 27, 42, 24, 54, 61, 51, 34, 58, 44, 44, 45, 56, 38, 40, 14,\n 57, 51, 25, 15, 35, 57, 51, 45, 16, 30, 29, 31, 45, 35, 47, 20, 20, 20,\n 34, 57, 61, 37, 34, 23, 31, 40, 46, 49, 59, 41, 39, 42, 23, 44, 29, 32,\n 31, 35, 19, 20, 54, 12, 35, 53, 40, 70, 39, 31, 43, 38, 28, 33, 38, 50,\n 33, 19, 30, 60, 45, 30, 43, 39, 47, 40, 33, 32, 15, 26, 53, 51, 63, 27,\n 55, 34, 56, 26, 56, 52, 42, 45, 39, 35, 65, 47, 33, 26, 50, 63, 24, 32,\n 34, 24, 47, 51, 66, 45, 42, 30, 49, 57, 40, 21, 21, 43, 31, 42, 33, 11,\n 75, 46, 40, 43, 34, 43, 38, 56, 42, 28, 51, 27, 44, 51, 28, 53, 41, 27,\n 27, 36, 50, 48, 56, 68, 28, 45, 54, 56, 33, 49, 26, 29, 33, 30, 53, 39,\n 26, 51, 19, 39, 27, 29, 56, 32, 40, 55, 40, 21, 32, 32, 19, 18, 54, 41,\n 27, 46, 43, 31, 17, 46, 31, 39, 39, 56, 34, 40, 23, 32, 28, 38, 21, 50,\n 51, 21, 37, 28, 35, 34, 48, 10, 45, 46, 62, 10, 24, 56, 60, 46, 54, 42,\n 47, 40, 20, 58, 45, 41, 16, 25, 72, 58, 42, 55, 36, 39, 31, 34, 6, 53,\n 52, 31, 46, 43, 24, 78, 56, 12, 43, 30, 59, 38, 48, 32, 11, 33, 36, 22,\n 53, 34, 70, 45, 40, 38, 30, 31, 70, 46, 20, 72, 35, 22, 32, 39, 44, 58,\n 34, 32, 41, 81, 52, 62, 27, 50, 29, 51, 40, 37, 48, 50, 48, 45, 9, 16,\n 33, 42, 50, 66, 16, 12, 77, 21, 58, 22, 38, 12, 27, 57, 19, 61, 41, 33,\n 25, 35, 61, 60, 66, 22, 56, 59, 34, 35, 38, 53, 53, 40, 36, 13, 27, 25,\n 35, 35, 66, 41, 64, 47, 62, 50, 36, 48, 33, 41, 39, 45, 49, 35, 63, 37,\n 16, 42, 35, 45, 24, 48, 35, 48, 21, 14, 22, 63, 26, 23, 40, 59, 48, 58,\n 44, 32, 69, 72, 41, 41, 51, 15, 29, 22, 42, 49, 40, 35, 48, 18, 29, 23,\n 25, 28, 54, 19, 13, 67, 37, 43, 31, 13, 46, 30, 29, 47, 48, 46, 49, 31,\n 38, 40, 54, 39, 49, 49, 50, 16, 20, 33, 46, 59, 33, 46, 49, 36, 41, 32,\n 44, 52, 49, 76, 32, 42, 45, 52, 47, 38, 21, 49, 22, 63, 35, 34, 51, 42,\n 73, 30, 62, 55, 25, 56, 51, 48, 49, 51, 52, 24, 55, 50, 25, 17, 30, 31,\n 33, 25, 47, 29, 38, 16, 28, 35, 51, 40, 4, 52, 15, 30, 27, 41, 43, 72,\n 21, 52, 47, 22, 51, 71, 29, 62, 38, 26, 64, 19, 32, 49, 39, 47, 56, 39,\n 51, 36, 51, 36, 57, 79, 41, 40, 47, 30, 31, 54, 45, 16, 22, 40, 46, 23,\n 27, 53, 53, 33, 19, 9, 11, 56, 45, 34, 37, 53, 50, 36, 48, 49, 40, 49,\n 32, 45, 19, 48, 33, 33, 36, 52, 32, 50, 27, 31, 19, 30, 21, 54, 68, 64,\n 28, 56, 8, 55, 34, 22, 54, 30, 60, 37, 29, 18, 20, 10, 17, 19, 27, 41,\n 35, 34, 55, 28, 51, 35, 22, 47, 41, 44, 46, 28, 20, 22, 28, 47, 50, 86,\n 43, 50, 20, 13, 55, 54, 45, 50, 51, 21, 53, 42, 45, 46, 39, 48, 47, 35,\n 14, 29, 29, 56, 57, 51, 42, 21, 40, 26, 55, 41, 32, 37, 16, 58, 52, 42,\n 58, 35, 61, 38, 15, 54, 8, 44, 47, 30, 69, 36, 42, 27, 28, 45, 45, 68,\n 18, 50, 55, 21, 32, 36, 33, 48, 29, 42, 23, 65, 37, 31, 25, 37, 52, 39,\n 11, 26, 51, 80, 35, 37, 40, 40, 31, 67, 35, 36, 41, 72, 34, 64, 17, 35,\n 44, 22, 37, 67, 49, 65, 53, 52, 40, 34, 35, 22, 43, 17, 43, 56, 46, 31,\n 16, 39, 39, 47, 58, 47, 43, 32, 18, 42, 48, 61, 46, 37, 46, 61, 57, 41,\n 29, 34, 17, 53, 18, 51, 44, 38, 55, 44, 59, 32, 64, 19, 30, 12, 34, 45,\n 35, 26, 20, 33, 9, 12, 52, 29, 23, 28, 28, 59, 34, 30, 51, 45, 9, 22, 34,\n 33, 17, 29, 45, 13, 15, 24, 51, 24, 48, 27, 33, 53, 28, 16, 34, 35, 37,\n 11, 57, 17, 59, 30, 36, 60, 69, 48, 33, 32, 35, 50, 29, 34, 55, 12, 28,\n 12, 42, 33, 50, 62, 14, 61, 50, 43, 56, 22, 45, 32, 26, 63, 19, 6, 24,\n 28, 25, 31, 38, 48, 73, 49, 29, 16, 37, 50, 54, 56, 19, 61, 47, 31, 28,\n 42, 66, 45, 75, 55, 27, 13, 16, 49, 26, 28, 66, 24, 35, 59, 38, 47, 23,\n 19, 34, 30, 49, 36, 48, 25, 5, 27, 46, 46, 22, 54, 9, 61, 17, 41, 43, 34,\n 29, 56, 44, 38, 36, 23, 31, 60, 44, 23, 38, 33, 20, 28, 28, 56, 45, 25,\n 40, 51, 55, 38, 36, 48, 45, 62, 66, 58, 30, 36, 40, 55, 36, 51, 57, 24,\n 49, 32, 29, 26, 45, 33, 39, 36, 55, 21, 17, 23, 38, 26, 72, 48, 46, 40,\n 58, 36, 39, 45, 31, 31, 48, 69, 22, 18, 65, 47, 56, 51, 32, 37, 29, 30,\n 38, 32, 30, 34, 34, 38, 46, 35, 33, 28, 54, 53, 78, 35, 60, 48, 32, 22,\n 35, 47, 20, 24, 20, 35, 50, 36, 58, 29, 40, 45, 22, 20, 27, 77, 24, 40,\n 31, 45, 50, 57, 47, 42, 34, 42, 48, 64, 43, 35, 44, 21, 26, 48, 32, 32,\n 22, 38, 30, 35, 40, 64, 32, 49, 28, 15, 43, 54, 22, 61, 45, 45, 39, 48,\n 39, 74, 52, 55, 50, 51, 42, 32, 29, 28, 13, 42, 39, 53, 48, 35, 45, 31,\n 38, 39, 26, 54, 23, 45, 30, 58, 31, 29, 47, 19, 74, 22, 41, 20, 70, 25,\n 32, 62, 16, 22, 64, 17, 50, 24, 49, 33, 20, 54, 15, 32, 67, 57, 38, 65,\n 35, 50, 55, 51, 23, 65, 31, 53, 36, 34, 49, 65, 32, 62, 33, 49, 52, 33,\n 47, 29, 36, 45, 24, 44, 30, 71, 32, 37, 36, 48, 48, 23, 36, 55, 23, 30,\n 37, 30, 48, 22, 39, 25, 27, 49, 34, 28, 33, 52, 55, 36, 60, 29, 44, 52,\n 48, 55, 16, 51, 41, 35, 30, 48, 33, 55, 24, 56, 50, 36, 49, 15, 37, 64,\n 56, 41, 15, 38, 21, 31, 61, 54, 32, 52, 41, 65, 41, 53, 37, 35, 23, 56,\n 40, 53, 11, 34, 53, 27, 48, 47, 80, 20, 57, 64, 44, 56, 26, 10, 31, 21,\n 32, 19, 26, 42, 27, 43, 59, 20, 70, 47, 17, 42, 13, 40, 45, 13, 47, 32,\n 42, 39, 63, 22, 30, 67, 63, 65, 37, 32, 53, 36, 43, 50, 12, 37, 39, 29,\n 35, 41, 40, 44, 50, 62, 33, 49, 43, 27, 46, 43, 13, 49, 49, 19, 42, 34,\n 44, 61, 59, 27, 30, 33, 45, 20, 21, 66, 47, 51, 49, 49, 32, 20, 74, 33,\n 66, 49, 45, 33, 29, 32, 18, 7, 37, 64, 43, 65, 25, 35, 45, 30, 31, 58,\n 29, 20, 9, 35, 13, 26, 41, 24, 50, 20, 64, 39, 35, 68, 40, 54, 48, 48,\n 67, 43, 51, 38, 35, 50, 65, 30, 46, 64, 27, 7, 46, 68, 53, 37, 66, 37, 3,\n 65, 50, 38, 31, 32, 29, 64, 34, 21, 32, 47, 27, 38, 31, 50, 54, 55, 34,\n 30, 24, 37, 42, 26, 24, 30, 46, 54, 29, 34, 39, 36, 16, 57, 50, 25, 21,\n 37, 43, 39, 40, 49, 44, 46, 13, 28, 41, 62, 32, 36, 30, 56, 37, 38, 72,\n 6, 47, 39, 37, 74, 36, 53, 31, 34, 28, 27, 47, 45, 54, 23, 50, 28, 49,\n 43, 45, 65, 21, 17, 35, 21, 16, 20, 47, 17, 45, 29, 24, 61, 50, 28, 26,\n 46, 18, 40, 27, 42, 46, 48, 24, 36, 23, 61, 55, 62, 56, 28, 36, 73, 61,\n 48, 41, 6, 18, 46, 48, 38, 48, 68, 26, 41, 28, 54, 36, 58, 27, 49, 40,\n 16, 44, 69, 36, 23, 35, 45, 55, 58, 39, 24, 43, 32, 45, 46, 50, 30, 44,\n 61, 57, 37, 45, 72, 33, 30, 50, 28, 23, 26, 36, 51, 36, 44, 37, 27, 38,\n 29, 47, 55, 27, 31, 17, 36, 53, 74, 44, 47, 36, 37, 35, 54, 26, 52, 34,\n 31, 49, 61, 27, 31, 29, 21, 47, 69, 49, 27, 49, 44, 41, 60, 57, 48, 48,\n 65, 50, 41, 53, 26, 47, 38, 22, 18, 44, 23, 52, 48, 45, 41, 18, 38, 42,\n 21, 45, 72, 46, 35, 49, 54, 54, 20, 43, 42, 63, 45, 38, 14, 22, 55, 51,\n 37, 12, 52, 38, 20, 43, 45, 78, 24, 21, 23, 20, 29, 24, 37, 46, 38, 22,\n 38, 33, 40, 31, 30, 25, 50, 14, 47, 29, 20, 56, 20, 42, 35, 44, 49, 68,\n 34, 15, 46, 40, 31, 57, 28, 35, 37, 16, 46, 12, 67, 39, 21, 23, 41, 59,\n 50, 13, 36, 73, 41, 29, 44, 45, 47, 59, 72, 51, 61, 23, 22, 27, 55, 37,\n 12, 57, 37, 67, 36, 17, 50, 29, 39, 41, 39, 32, 46, 47, 41, 42, 67, 45,\n 28, 37, 37, 59, 55, 51, 35, 18, 48, 46, 82, 35, 40, 62, 46, 20, 11, 50,\n 40, 11, 32, 35, 26, 63, 36, 35, 45, 61, 43, 50, 19, 17, 54, 55, 51, 35,\n 52, 38, 62, 37, 53, 40, 56, 25, 14, 36, 48, 56, 36, 19, 31, 45, 28, 52,\n 36, 40, 82, 33, 42, 50, 33, 19, 28, 13, 67, 63, 28, 44, 21, 85, 21, 34,\n 23, 60, 37, 53, 33, 49, 49, 56, 75, 37, 52, 37, 58, 42, 39, 31, 24, 54,\n 37, 29, 60, 58, 42, 27, 31, 53, 42, 43, 54, 47, 19, 26, 19, 45, 24, 30,\n 41, 26, 31, 46, 7, 48, 40, 47, 34, 30, 32, 33, 61, 48, 34, 48, 38, 51,\n 33, 22, 40, 49, 36, 46, 54, 64, 61, 50, 47, 44, 65, 65, 47, 31, 28, 30,\n 45, 43, 36, 51, 44, 66, 49, 19, 23, 45, 35, 17, 18, 37, 52, 27, 24, 52,\n 34, 51, 31, 63, 38, 36, 38, 30, 26, 9, 46, 54, 26, 29, 49, 23, 46, 40,\n 19, 23, 46, 29, 44, 46, 20, 15, 25, 30, 63, 60, 38, 30, 38, 35, 33, 35,\n 39, 51, 22, 34, 26, 26, 17, 34, 9, 21, 17, 23, 41, 18, 15, 44, 41, 30,\n 57, 43, 36, 40, 44, 32, 35, 44, 16, 41, 27, 46, 58, 47, 47, 25, 32, 42,\n 37, 22, 29, 21, 46, 33, 40, 77, 34, 18, 37, 33, 51, 65, 36, 38, 59, 48,\n 40, 22, 41, 17, 44, 39, 44, 22, 28, 41, 41, 62, 52, 41, 45, 54, 62, 39,\n 59, 48, 19, 54, 40, 45, 30, 33, 49, 26, 51, 42, 54, 48, 38, 33, 41, 27,\n 49, 51, 80, 29, 43, 56, 17, 29, 30, 32, 34, 41, 19, 38, 50, 15, 34, 54,\n 12, 24, 58, 31, 69, 26, 49, 52, 37, 55, 32, 46, 47, 54, 27, 33, 30, 36,\n 38, 28, 69, 43, 50, 45, 58, 59, 21, 41, 16, 41, 33, 16, 57, 28, 16, 13,\n 42, 19, 45, 52, 37, 23, 60, 27, 77, 32, 50, 49, 59, 44, 27, 46, 28, 53,\n 61, 15, 21, 43, 45, 42, 25, 64, 18, 64, 37, 35, 71, 51, 39, 23, 13, 3,\n 21, 71, 27, 37, 37, 71, 22, 58, 55, 46, 52, 69, 44, 30, 60, 14, 31, 32,\n 54, 48, 59, 30, 2, 21, 28, 22, 39, 7, 42, 39, 52, 57, 14, 13, 46, 37, 40,\n 33, 24, 60, 28, 54, 33, 49, 22, 23, 33, 23, 43, 53, 47, 40, 22, 18, 39,\n 41, 29, 62, 28, 49, 27, 45, 38, 30, 75, 25, 31, 45, 54, 17, 33, 18, 37,\n 38, 63, 46, 44, 45, 69, 42, 32, 46, 49, 36, 24, 45, 50, 18, 45, 44, 49,\n 23, 30, 57, 10, 87, 38, 66, 50, 44, 33, 17, 60, 58, 53, 32, 38, 48, 20,\n 31, 56, 43, 52, 35, 48, 37, 21, 24, 44, 42, 58, 28, 54, 56, 48, 28, 46,\n 73, 38, 62, 46, 44, 64, 40, 22, 54, 38, 41, 47, 47, 58, 19, 49, 28, 52,\n 41, 23, 31, 56, 32, 38, 53, 15, 21, 73, 58, 21, 34, 24, 22, 37, 39, 57,\n 16, 58, 42, 50, 71, 24, 41, 51, 33, 59, 18, 12, 24, 39, 33, 15, 73, 66,\n 47, 20, 27, 29, 31, 7, 44, 19, 31, 45, 34, 39, 38, 53, 67, 49, 52, 37,\n 40, 54, 36, 40, 31, 53, 27, 42, 40, 43, 29, 30, 22, 43, 78, 38, 30, 30,\n 24, 42, 63, 52, 6, 13, 12, 44, 27, 17, 50, 19, 36, 46, 45, 59, 61, 58,\n 59, 37, 22, 39, 44, 14, 58, 71, 74, 51, 41, 41, 49, 39, 45, 28, 33, 23,\n 36, 28, 43, 13, 28, 48, 44, 40, 59, 50, 29, 41, 72, 22, 16, 44, 44, 47,\n 39, 45, 58, 29, 68, 47, 59, 13, 51, 14, 45, 39, 49, 57, 47, 58, 70, 53,\n 28, 37, 52, 53, 42, 42, 45, 54, 56, 82, 38, 55, 30, 33, 53, 44, 64, 33,\n 38, 37, 19, 38, 37, 53, 46, 25, 46, 13, 29, 50, 61, 49, 56, 53, 61, 30,\n 34, 47, 54, 22, 13, 50, 42, 30, 16, 16, 38, 40, 18, 24, 16, 44, 30, 52,\n 44, 29, 50, 34, 64, 8, 42, 41, 55, 55, 57, 32, 23, 16, 41, 40, 37, 27,\n 10, 52, 69, 24, 40, 55, 35, 47, 30, 40, 46, 40, 10, 24, 30, 36, 73, 26,\n 28, 29, 60, 64, 54, 52, 53, 33, 33, 40, 23, 51, 66, 62, 55, 37, 30, 24,\n 40, 71, 17, 50, 31, 23, 38, 35, 46, 32, 50, 42, 47, 48, 36, 47, 29, 22,\n 41, 60, 66, 57, 18, 20, 61, 38, 17, 40, 31, 42, 47, 44, 60, 9, 33, 37,\n 34, 62, 49, 27, 44, 22, 25, 52, 44, 46, 18, 42, 46, 16, 31, 21, 35, 31,\n 67, 46, 32, 38, 40, 42, 39, 23, 20, 28, 21, 34, 22, 33, 60, 49, 52, 25,\n 46, 59, 48, 55, 45, 38, 40, 28, 43, 7, 39, 80, 34, 15, 32, 38, 68, 42,\n 52, 61, 70, 28, 54, 50, 52, 45, 35, 39, 27, 29, 65, 35, 24, 52, 8, 32,\n 62, 29, 51, 48, 37, 54, 29, 45, 33, 31, 69, 33, 14, 35, 39, 30, 29, 64,\n 64, 12, 24, 16, 40, 53, 49, 39, 52, 40, 29, 52, 60, 50, 51, 44, 18, 65,\n 58, 28, 51, 61, 56, 53, 21, 34, 62, 63, 59, 35, 44, 46, 56, 48, 32, 52,\n 25, 34, 33, 40, 16, 17, 42, 46, 51, 40, 43, 31, 68, 24, 49, 37, 31, 38,\n 24, 29, 65, 12, 53, 63, 32, 7, 41, 32, 26, 35, 42, 25, 29, 28, 46, 56,\n 34, 50, 9, 53, 29, 14, 48, 61, 33, 46, 40, 6, 65, 26, 65, 30, 43, 22, 27,\n 48, 60, 32, 21, 63, 30, 55, 54, 29, 65, 23, 20, 41, 52, 22, 28, 48, 33,\n 22, 55, 43, 64, 73, 45, 49, 53, 17, 71, 31, 56, 44, 35, 39, 32, 53, 38,\n 32, 40, 49, 58, 25, 46, 11, 30, 35, 43, 40, 40, 38, 27, 41, 31, 34, 58,\n 33, 21, 54, 66, 53, 26, 62, 27, 13, 59, 9, 48, 20, 34, 29, 27, 50, 69,\n 36, 28, 18, 22, 34, 51, 28, 66, 30, 55, 53, 50, 43, 60, 28, 31, 24, 34,\n 47, 26, 36, 16, 38, 47, 51, 65, 36, 34, 14, 40, 17, 55, 23, 33, 44, 27,\n 62, 59, 31, 6, 43, 19, 63, 21, 32, 61, 26, 39, 12, 35, 33, 48, 7, 41, 58,\n 47, 15, 45, 51, 59, 43, 56, 33, 26, 40, 50, 57, 31, 46, 27, 62, 39, 44,\n 45, 36, 46, 37, 44, 43, 35, 45, 53, 10, 7, 45, 33, 23, 29, 30, 35, 66,\n 34, 66, 37, 54, 30, 23, 48, 62, 60, 45, 68, 42, 50, 47, 51, 22, 43, 52,\n 40, 46, 46, 14, 7, 35, 33, 18, 52, 56, 18, 63, 43, 18, 49, 61, 58, 32,\n 33, 15, 12, 38, 47, 15, 39, 38, 44, 52, 47, 44, 58, 23, 23, 47, 38, 40,\n 66, 28, 19, 22, 25, 21, 38, 39, 57, 45, 14, 38, 23, 62, 25, 69, 30, 52,\n 29, 20, 51, 40, 30, 42, 36, 25, 48, 47, 54, 8, 23, 59, 32, 78, 50, 27,\n 42, 28, 33, 40, 29, 32, 21, 39, 59, 69, 42, 40, 16, 51, 27, 45, 38, 42,\n 66, 38, 26, 28, 44, 51, 54, 65, 39, 70, 29, 42, 48, 41, 51, 48, 51, 23,\n 58, 33, 43, 35, 50, 54, 38, 40, 43, 74, 29, 56, 55, 40, 20, 47, 43, 23,\n 45, 12, 50, 42, 56, 22, 32, 10, 26, 47, 54, 21, 8, 37, 34, 32, 42, 41,\n 15, 28, 58, 19, 35, 34, 47, 8, 30, 68, 21, 41, 25, 18, 60, 60, 48, 59,\n 56, 32, 32, 86, 17, 64, 51, 60, 19, 47, 41, 39, 23, 23, 62, 36, 41, 35,\n 49, 27, 28, 60, 11, 55, 35, 38, 14, 62, 28, 12, 55, 11, 34, 27, 46, 55,\n 31, 51, 24, 66, 49, 51, 39, 55, 21, 43, 40, 36, 39, 65, 38, 29, 46, 33,\n 27, 27, 26, 19, 25, 29, 30, 23, 50, 44, 19, 35, 34, 67, 51, 38, 53, 22,\n 42, 21, 61, 43, 28, 44, 12, 27, 36, 61, 40, 61, 39, 54, 30, 25, 44, 17,\n 54, 55, 29, 34, 31, 48, 39, 41, 61, 33, 62, 46, 36, 9, 45, 32, 54, 59,\n 48, 51, 37, 35, 33, 36, 53, 51, 46, 49, 18, 59, 27, 42, 50, 26, 52, 35,\n 26, 37, 47, 37, 41, 48, 54, 35, 40, 35, 24, 34, 33, 43, 44, 17, 45, 26,\n 56, 29, 43, 45, 14, 16, 42, 54, 31, 49, 59, 68, 16, 20, 63, 52, 47, 51,\n 64, 39, 49, 41, 65, 38, 30, 34, 9, 26, 32, 27, 20, 39, 71, 49, 16, 39,\n 52, 49, 64, 37, 33, 26, 46, 19, 51, 36, 51, 20, 49, 63, 67, 68, 48, 14,\n 51, 54, 43, 36, 41, 18, 39, 44, 61, 36, 40, 29, 35, 32, 63, 41, 21, 35,\n 43, 28, 53, 55, 67, 57, 35, 54, 57, 52, 33, 63, 25, 34, 57, 77, 45, 57,\n 30, 51, 44, 53, 42, 51, 33, 34, 63, 41, 45, 35, 40, 48, 25, 53, 48, 50,\n 37, 37, 55, 52, 30, 44, 35, 41, 51, 45, 42, 35, 35, 23, 34, 28, 37, 38,\n 63, 61, 52, 67, 52, 41, 63, 39, 33, 56, 39, 50, 63, 42, 29, 41, 38, 59,\n 10, 52, 56, 53, 39, 41, 43, 68, 49, 33, 43, 41, 40, 38, 20, 42, 48, 30,\n 65, 22, 49, 40, 34, 62, 30, 32, 28, 40, 44, 40, 2, 68, 35, 31, 48, 44,\n 13, 79, 27, 22, 51, 40, 28, 31, 57, 54, 47, 20, 61, 20, 26, 53, 25, 48,\n 27, 23, 40, 54, 24, 57, 22, 73, 25, 44, 42, 40, 52, 18, 17, 34, 40, 30,\n 35, 30, 46, 35, 46, 15, 18, 19, 28, 46, 81, 53, 42, 48, 36, 61, 25, 40,\n 25, 34, 66, 34, 29, 48, 39, 53, 40, 31, 28, 57, 45, 33, 12, 28, 21, 53,\n 47, 50, 38, 54, 44, 26, 27, 10, 46, 33, 46, 53, 50, 45, 31, 34, 43, 40,\n 43, 55, 39, 45, 33, 51, 25, 62, 31, 25, 28, 34, 52, 24, 23, 36, 87, 32,\n 54, 42, 26, 52, 46, 58, 39, 63, 51, 22, 31, 35, 42, 42, 49, 36, 24, 63,\n 69, 27, 49, 50, 39, 22, 28, 40, 31, 34, 42, 36, 43, 51, 45, 20, 28, 63,\n 54, 19, 54, 49, 25, 49, 21, 47, 36, 42, 38, 33, 24, 19, 31, 35, 39, 49,\n 9, 44, 27, 16, 47, 33, 45, 50, 51, 37, 36, 32, 64, 41, 47, 53, 59, 29,\n 69, 28, 65, 42, 44, 31, 47, 37, 37, 25, 62, 39, 28, 51, 55, 62, 39, 39,\n 38, 54, 45, 18, 54, 44, 26, 34, 52, 32, 28, 58, 29, 38, 39, 55, 46, 26,\n 60, 23, 50, 34, 40, 58, 31, 46, 36, 31, 54, 46, 54, 27, 77, 62, 55, 36,\n 20, 53, 54, 37, 50, 59, 34, 37, 44, 33, 27, 62, 29, 31, 57, 44, 43, 46,\n 40, 22, 45, 33, 31, 39, 51, 51, 51, 48, 61, 61, 22, 48, 47, 49, 35, 33,\n 15, 10, 34, 33, 52, 81, 50, 59, 57, 41, 21, 45, 64, 56, 30, 39, 37, 47,\n 42, 46, 23, 59, 25, 23, 48, 58, 16, 39, 20, 46, 52, 23, 55, 43, 40, 36,\n 28, 44, 28, 21, 60, 39, 27, 55, 39, 38, 46, 27, 40, 60, 40, 38, 22, 48,\n 41, 24, 20, 49, 36, 27, 17, 67, 36, 66, 42, 48, 49, 89, 31, 38, 40, 10,\n 24, 63, 35, 67, 43, 54, 15, 31, 41, 60, 53, 31, 34, 15, 35, 33, 19, 38,\n 22, 32, 32, 33, 59, 54, 18, 40, 18, 37, 41, 30, 36, 49, 56, 43, 52, 33,\n 62, 25, 28, 36, 16, 50, 19, 47, 69, 16, 32, 41, 45, 45, 42, 61, 61, 29,\n 25, 40, 39, 49, 52, 45, 37, 51, 32, 32, 55, 82, 42, 17, 30, 53, 34, 60,\n 38, 44, 49, 31, 48, 40, 24, 35, 14, 37, 23, 56, 41, 28, 22, 17, 47, 28,\n 47, 39, 32, 49, 26, 53, 31, 24, 32, 45, 65, 25, 26, 43, 34, 51, 29, 27,\n 53, 77, 24, 48, 38, 39, 15, 75, 18, 56, 45, 71, 32, 41, 46, 19, 51, 50,\n 44, 59, 46, 41, 16, 23, 75, 55, 31, 35, 75, 44, 50, 57, 40, 59, 63, 29,\n 52, 32, 45, 25, 33, 39, 46, 63, 23, 37, 47, 23, 40, 38, 16, 23, 38, 23,\n 32, 38, 56, 26, 51, 30, 26, 15, 24, 49, 49, 34, 33, 44, 32, 10, 14, 30,\n 37, 34, 36, 74, 38, 29, 33, 23, 45, 34, 40, 25, 39, 18, 50, 71, 40, 27,\n 22, 35, 11, 24, 52, 38, 24, 51, 27, 36, 52, 16, 40, 44, 55, 29, 6, 43,\n 41, 32, 38, 53, 43, 36, 25, 54, 34, 50, 66, 46, 67, 19, 47, 34, 27, 38,\n 34, 44, 28, 31, 51, 34, 46, 38, 44, 61, 35, 53, 17, 25, 35, 48, 52, 34,\n 26, 17, 37, 37, 22, 19, 60, 48, 68, 75, 44, 26, 37, 55, 31, 31, 54, 51,\n 64, 67, 20, 62, 41, 45, 25, 35, 25, 15, 47, 48, 17, 36, 40, 43, 48, 36,\n 40, 28, 54, 52, 19, 40, 47, 26, 42, 48, 22, 51, 22, 46, 59, 51, 24, 50,\n 47, 17, 52, 23, 45, 19, 63, 30, 47, 46, 46, 22, 41, 62, 26, 14, 31, 48,\n 50, 68, 38, 33, 42, 44, 44, 19, 19, 11, 13, 33, 48, 54, 46, 48, 24, 16,\n 58, 21, 18, 38, 44, 26, 57, 41, 55, 53, 37, 35, 55, 52, 32, 40, 54, 41,\n 60, 46, 48, 34, 17, 45, 41, 37, 39, 22, 26, 16, 44, 49, 65, 15, 42, 37,\n 22, 26, 47, 37, 19, 48, 69, 43, 52, 43, 20, 46, 35, 25, 54, 26, 34, 43,\n 41, 44, 47, 8, 77, 30, 17, 46, 9, 58, 43, 41, 65, 50, 49, 38, 61, 44, 54,\n 22, 33, 31, 30, 19, 49, 56, 18, 68, 27, 47, 43, 13, 53, 41, 28, 54, 52,\n 27, 36, 29, 34, 46, 45, 39, 84, 29, 30, 28, 43, 55, 30, 13, 24, 41, 29,\n 30, 21, 21, 40, 60, 40, 33, 68, 25, 25, 53, 20, 56, 51, 26, 20, 47, 34,\n 64, 21, 33, 25, 62, 36, 48, 46, 43, 42, 66, 77, 29, 39, 34, 35, 16, 30,\n 10, 33, 57, 41, 36, 23, 50, 14, 32, 17, 31, 27, 62, 28, 35, 30, 60, 45,\n 22, 33, 26, 70, 49, 28, 35, 32, 39, 22, 59, 44, 19, 37, 28, 45, 13, 9,\n 41, 38, 21, 44, 12, 64, 44, 48, 43, 58, 26, 40, 26, 54, 27, 30, 31, 41,\n 37, 33, 31, 47, 48, 42, 20, 46, 23, 36, 59, 33, 38, 20, 65, 51, 33, 46,\n 33, 32, 39, 41, 31, 63, 67, 44, 57, 17, 76, 32, 41, 42, 41, 33, 16, 71,\n 33, 32, 37, 29, 59, 70, 38, 39, 61, 26, 49, 70, 61, 42, 60, 46, 21, 46,\n 32, 47, 37, 29, 41, 43, 50, 34, 35, 23, 35, 59, 40, 38, 45, 30, 50, 37,\n 54, 76, 24, 40, 50, 19, 67, 35, 55, 75, 49, 28, 12, 55, 45, 78, 43, 55,\n 56, 35, 41, 42, 27, 58, 25, 52, 45, 32, 29, 15, 43, 25, 8, 31, 32, 16,\n 32, 38, 44, 23, 21, 37, 48, 37, 40, 22, 14, 29, 55, 26, 19, 46, 26, 22,\n 30, 56, 23, 8, 48, 33, 23, 63, 71, 53, 52, 24, 56, 49, 20, 40, 53, 36,\n 61, 56, 15, 31, 44, 35, 60, 46, 50, 54, 36, 55, 22, 25, 40, 40, 49, 46,\n 53, 19, 51, 51, 27, 51, 53, 22, 25, 21, 25, 18, 42, 55, 43, 39, 27, 42,\n 6, 38, 42, 62, 10, 39, 15, 32, 25, 48, 24, 41, 39, 75, 41, 22, 52, 11,\n 29, 54, 42, 30, 16, 21, 22, 42, 21, 64, 16, 18, 57, 47, 42, 3, 36, 13,\n 29, 52, 34, 28, 39, 74, 43, 50, 43, 42, 68, 22, 49, 35, 51, 47, 29, 36,\n 35, 27, 53, 13, 84, 29, 18, 33, 54, 54, 67, 45, 53, 41, 54, 18, 49, 39,\n 36, 46, 17, 31, 23, 33, 50, 39, 33, 43, 19, 35, 29, 41, 72, 52, 53, 45,\n 64, 26, 26, 45, 38, 31, 21, 31, 16, 15, 38, 32, 55, 26, 20, 37, 50, 20,\n 23, 50, 58, 82, 38, 54, 14, 47, 13, 21, 61, 38, 38, 14, 42, 55, 42, 45,\n 51, 58, 33, 37, 44, 44, 37, 10, 49, 63, 60, 35, 27, 47, 71, 60, 25, 46,\n 51, 29, 49, 51, 36, 17, 32, 32, 49, 24, 22, 35, 28, 87, 29, 34, 30, 23,\n 38, 31, 28, 33, 30, 40, 11, 59, 37, 69, 37, 53, 29, 55, 43, 46, 40, 21,\n 69, 44, 19, 41, 48, 33, 30, 24, 51, 37, 22, 22, 32, 54, 35, 47, 39, 9,\n 61, 53, 26, 60, 34, 48, 55, 32, 21, 27, 36, 35, 33, 34, 15, 38, 38, 41,\n 54, 50, 45, 26, 26, 38, 36, 29, 43, 43, 65, 46, 18, 53, 32, 14, 46, 31,\n 43, 13, 34, 33, 43, 68, 55, 18, 30, 52, 14, 31, 24, 9, 56, 24, 64, 65,\n 61, 38, 46, 58, 50, 49, 40, 56, 62, 47, 58, 50, 21, 17, 52, 22, 46, 51,\n 32, 55, 54, 50, 43, 36, 66, 63, 17, 61, 43, 40, 19, 45, 44, 42, 11, 46,\n 35, 23, 30, 29, 54, 26, 44, 16, 43, 26, 60, 32, 21, 11, 28, 37, 41, 46,\n 29, 60, 36, 46, 38, 59, 49, 31, 13, 28, 44, 50, 36, 34, 46, 38, 45, 54,\n 54, 37, 38, 30, 26, 47, 56, 52, 35, 40, 32, 34, 37, 44, 58, 43, 46, 83,\n 44, 32, 24, 39, 47, 16, 49, 11, 37, 52, 20, 43, 25, 46, 14, 44, 21, 45,\n 62, 15, 36, 26, 29, 47, 58, 42, 38, 40, 39, 26, 25, 21, 44, 28, 55, 57,\n 43, 34, 49, 19, 50, 34, 21, 31, 50, 35, 34, 51, 41, 69, 66, 21, 44, 26,\n 22, 47, 66, 43, 43, 65, 28, 30, 30, 25, 12, 31, 55, 28, 39, 33, 41, 33,\n 46, 9, 40, 65, 41, 27, 47, 50, 12, 19, 50, 52, 33, 49, 38, 39, 42, 67,\n 55, 36, 47, 23, 54, 34, 32]},\n 'test_2': {'capacity': 100, 'num_items': 5000,\n 'items': [20, 47, 39, 29, 7, 45, 45, 18, 39, 48, 15, 25, 33, 40, 52, 32, 33, 30,\n 11, 57, 15, 44, 22, 23, 83, 19, 34, 17, 14, 34, 50, 36, 52, 62, 48, 68,\n 40, 33, 27, 18, 25, 37, 39, 46, 35, 50, 60, 66, 52, 32, 31, 25, 62, 38,\n 54, 31, 58, 34, 20, 42, 57, 19, 21, 30, 21, 29, 20, 47, 43, 31, 34, 70,\n 19, 27, 17, 61, 53, 20, 69, 37, 32, 40, 49, 47, 26, 55, 52, 62, 41, 53,\n 17, 16, 42, 43, 49, 41, 41, 38, 25, 41, 42, 28, 14, 40, 50, 47, 16, 26,\n 38, 46, 35, 39, 77, 14, 55, 51, 43, 41, 23, 27, 60, 60, 38, 14, 31, 54,\n 23, 44, 44, 32, 32, 27, 24, 40, 51, 8, 46, 29, 10, 48, 65, 31, 55, 13,\n 23, 50, 28, 13, 38, 60, 27, 32, 22, 25, 45, 54, 38, 35, 23, 60, 77, 77,\n 24, 27, 28, 45, 17, 54, 45, 55, 42, 32, 42, 67, 55, 33, 57, 41, 35, 16,\n 35, 36, 45, 23, 24, 34, 35, 37, 48, 57, 57, 46, 47, 51, 59, 60, 42, 31,\n 63, 40, 31, 37, 11, 20, 49, 51, 33, 49, 53, 31, 51, 44, 39, 30, 41, 17,\n 43, 51, 33, 17, 39, 42, 38, 52, 55, 46, 55, 45, 58, 43, 59, 40, 42, 5,\n 45, 31, 28, 36, 52, 53, 48, 47, 9, 38, 45, 27, 34, 38, 47, 51, 34, 44,\n 40, 14, 67, 56, 30, 25, 42, 37, 21, 31, 69, 51, 46, 45, 55, 26, 58, 45,\n 50, 58, 44, 66, 27, 23, 28, 50, 39, 74, 30, 12, 24, 18, 27, 40, 55, 59,\n 58, 37, 29, 17, 17, 37, 21, 16, 41, 17, 39, 33, 42, 30, 60, 31, 32, 23,\n 32, 28, 17, 60, 24, 36, 29, 25, 81, 43, 44, 51, 51, 46, 28, 32, 36, 57,\n 39, 32, 31, 46, 35, 25, 70, 46, 50, 53, 50, 35, 49, 30, 33, 64, 41, 25,\n 29, 47, 26, 61, 54, 64, 29, 35, 35, 58, 47, 26, 58, 8, 66, 41, 64, 52,\n 22, 34, 38, 17, 14, 44, 33, 24, 36, 56, 49, 29, 35, 23, 15, 49, 79, 42,\n 36, 18, 50, 32, 27, 44, 36, 50, 51, 24, 83, 48, 35, 33, 37, 14, 32, 33,\n 34, 38, 40, 63, 31, 41, 51, 34, 71, 56, 37, 46, 52, 62, 36, 35, 57, 43,\n 26, 36, 43, 53, 17, 66, 39, 23, 42, 39, 17, 53, 57, 32, 44, 32, 44, 30,\n 53, 32, 41, 22, 38, 39, 15, 22, 45, 46, 59, 35, 31, 14, 37, 38, 24, 33,\n 53, 29, 39, 37, 61, 36, 47, 37, 29, 25, 47, 42, 31, 41, 59, 55, 28, 44,\n 49, 50, 33, 41, 51, 43, 32, 58, 55, 38, 49, 38, 36, 40, 54, 72, 53, 51,\n 42, 47, 49, 48, 57, 52, 33, 27, 33, 28, 41, 22, 48, 25, 50, 23, 41, 36,\n 54, 55, 25, 53, 26, 8, 47, 44, 48, 26, 8, 50, 39, 44, 68, 44, 70, 50, 44,\n 52, 39, 64, 41, 64, 52, 38, 16, 20, 11, 41, 25, 29, 35, 37, 17, 21, 46,\n 40, 32, 25, 14, 57, 29, 31, 20, 32, 48, 70, 48, 20, 61, 57, 25, 59, 35,\n 80, 27, 26, 54, 45, 54, 50, 46, 23, 48, 31, 40, 27, 43, 24, 48, 61, 36,\n 41, 41, 31, 42, 55, 49, 48, 37, 20, 35, 45, 37, 11, 32, 54, 50, 4, 24,\n 61, 48, 63, 38, 43, 38, 27, 20, 52, 22, 11, 38, 53, 27, 43, 26, 40, 47,\n 38, 42, 56, 52, 72, 53, 40, 25, 50, 43, 49, 32, 55, 25, 51, 37, 41, 56,\n 47, 37, 57, 29, 27, 60, 34, 42, 61, 46, 31, 38, 54, 48, 34, 55, 59, 38,\n 43, 22, 27, 28, 29, 30, 53, 60, 16, 55, 13, 39, 29, 28, 44, 42, 53, 60,\n 33, 48, 48, 44, 40, 57, 50, 59, 28, 31, 65, 23, 27, 44, 46, 57, 36, 60,\n 23, 23, 58, 51, 47, 15, 57, 50, 33, 14, 42, 44, 19, 24, 42, 40, 51, 37,\n 33, 50, 39, 38, 28, 31, 49, 55, 68, 42, 81, 21, 38, 55, 49, 39, 31, 36,\n 59, 62, 62, 79, 36, 55, 57, 23, 24, 32, 18, 53, 34, 70, 32, 38, 40, 43,\n 41, 35, 30, 53, 24, 47, 38, 36, 30, 52, 28, 67, 58, 23, 29, 33, 21, 54,\n 42, 44, 41, 33, 52, 35, 42, 39, 44, 50, 34, 53, 29, 50, 26, 8, 41, 39,\n 25, 48, 34, 45, 30, 35, 38, 57, 65, 34, 33, 47, 28, 42, 62, 42, 12, 31,\n 51, 13, 51, 47, 28, 76, 54, 34, 66, 18, 51, 32, 27, 48, 46, 15, 36, 43,\n 58, 35, 32, 41, 43, 16, 52, 22, 70, 19, 34, 25, 45, 27, 41, 33, 43, 47,\n 43, 62, 29, 62, 56, 33, 23, 72, 66, 44, 28, 29, 16, 20, 55, 53, 48, 59,\n 44, 44, 39, 14, 42, 40, 47, 67, 28, 51, 19, 44, 42, 41, 50, 12, 47, 37,\n 38, 11, 31, 51, 25, 29, 5, 22, 32, 51, 44, 56, 61, 43, 16, 50, 38, 20,\n 62, 70, 31, 37, 30, 69, 46, 13, 19, 45, 20, 10, 42, 34, 64, 56, 10, 35,\n 41, 32, 34, 48, 61, 55, 37, 49, 40, 26, 42, 35, 44, 41, 62, 29, 34, 34,\n 41, 54, 55, 35, 34, 37, 30, 29, 36, 62, 35, 38, 45, 31, 35, 37, 43, 38,\n 48, 45, 43, 28, 50, 49, 42, 64, 29, 75, 47, 60, 30, 55, 56, 62, 48, 35,\n 36, 22, 43, 56, 30, 37, 41, 21, 31, 60, 56, 15, 38, 32, 53, 25, 26, 36,\n 65, 40, 30, 42, 54, 47, 10, 11, 36, 61, 31, 53, 33, 21, 58, 42, 39, 43,\n 83, 44, 26, 25, 52, 10, 30, 29, 45, 30, 56, 39, 12, 38, 56, 33, 29, 31,\n 42, 36, 25, 24, 44, 54, 43, 48, 29, 38, 57, 50, 21, 67, 42, 28, 38, 22,\n 68, 11, 38, 15, 28, 58, 47, 24, 43, 50, 27, 17, 38, 20, 39, 53, 34, 61,\n 37, 57, 30, 20, 33, 65, 43, 44, 65, 38, 38, 15, 69, 49, 40, 30, 41, 14,\n 45, 43, 27, 56, 30, 45, 53, 39, 72, 32, 35, 15, 48, 18, 66, 54, 58, 44,\n 40, 40, 48, 25, 33, 62, 38, 43, 38, 20, 21, 29, 45, 35, 41, 61, 48, 25,\n 42, 36, 25, 34, 51, 39, 46, 53, 68, 21, 26, 18, 49, 49, 12, 29, 29, 46,\n 63, 38, 32, 49, 67, 28, 39, 19, 42, 55, 44, 44, 29, 26, 29, 33, 24, 22,\n 22, 57, 55, 29, 19, 34, 59, 43, 45, 37, 58, 80, 28, 76, 39, 51, 20, 32,\n 55, 34, 43, 65, 14, 60, 41, 33, 30, 35, 38, 51, 37, 49, 33, 43, 34, 21,\n 91, 9, 67, 41, 52, 24, 45, 35, 38, 35, 33, 37, 52, 42, 37, 45, 24, 44,\n 38, 32, 47, 38, 47, 65, 73, 31, 47, 46, 29, 70, 35, 36, 19, 34, 59, 46,\n 23, 31, 31, 21, 33, 32, 32, 43, 43, 23, 66, 52, 20, 35, 51, 47, 23, 58,\n 40, 44, 43, 12, 75, 41, 31, 35, 30, 48, 34, 28, 47, 43, 53, 37, 57, 36,\n 37, 45, 41, 60, 34, 33, 41, 17, 26, 67, 63, 46, 69, 29, 46, 27, 51, 38,\n 39, 47, 33, 31, 58, 38, 32, 53, 39, 41, 44, 20, 15, 23, 52, 44, 46, 49,\n 40, 13, 46, 25, 52, 48, 44, 29, 70, 42, 41, 19, 36, 54, 28, 48, 42, 34,\n 64, 13, 22, 46, 60, 58, 65, 52, 46, 38, 56, 36, 52, 18, 41, 64, 59, 41,\n 47, 20, 64, 15, 33, 72, 45, 36, 51, 47, 39, 38, 30, 58, 78, 56, 47, 38,\n 53, 36, 21, 62, 57, 37, 46, 54, 14, 36, 58, 67, 42, 41, 37, 31, 30, 55,\n 59, 46, 42, 31, 42, 22, 24, 62, 36, 52, 44, 54, 30, 24, 61, 19, 49, 63,\n 52, 57, 42, 9, 66, 17, 54, 23, 40, 27, 59, 53, 45, 48, 42, 22, 22, 42,\n 51, 47, 30, 40, 26, 34, 50, 47, 33, 37, 27, 31, 45, 61, 34, 40, 36, 29,\n 59, 34, 56, 38, 24, 32, 51, 47, 26, 22, 69, 25, 58, 25, 57, 11, 45, 15,\n 54, 34, 52, 16, 47, 29, 54, 18, 29, 32, 66, 43, 51, 37, 59, 46, 35, 19,\n 44, 43, 35, 18, 36, 59, 36, 33, 42, 42, 48, 35, 36, 5, 19, 35, 39, 63,\n 25, 44, 42, 41, 61, 52, 37, 42, 37, 48, 51, 65, 41, 30, 29, 25, 44, 48,\n 74, 19, 22, 40, 28, 45, 35, 44, 35, 46, 27, 41, 75, 42, 19, 27, 39, 50,\n 19, 49, 32, 38, 71, 50, 24, 45, 31, 33, 23, 45, 32, 30, 60, 33, 25, 25,\n 34, 14, 46, 37, 38, 30, 34, 31, 49, 62, 42, 33, 39, 49, 23, 65, 27, 29,\n 81, 59, 54, 43, 31, 56, 23, 59, 65, 44, 50, 59, 45, 32, 41, 29, 11, 14,\n 25, 37, 22, 37, 44, 62, 44, 28, 53, 9, 49, 44, 34, 49, 67, 51, 37, 26,\n 45, 28, 24, 57, 31, 54, 16, 36, 32, 22, 28, 19, 24, 39, 69, 46, 22, 39,\n 58, 45, 41, 23, 26, 60, 35, 50, 43, 35, 57, 32, 19, 45, 10, 42, 36, 15,\n 78, 40, 57, 21, 33, 56, 51, 15, 67, 26, 25, 64, 38, 36, 39, 43, 30, 35,\n 34, 44, 29, 29, 18, 32, 40, 68, 46, 24, 40, 48, 31, 40, 19, 36, 45, 57,\n 17, 18, 31, 31, 31, 25, 53, 42, 34, 21, 48, 30, 7, 56, 48, 25, 32, 52,\n 44, 32, 55, 57, 59, 63, 48, 33, 9, 12, 44, 42, 50, 44, 37, 56, 57, 26,\n 42, 27, 49, 31, 24, 14, 31, 51, 26, 15, 27, 37, 37, 57, 30, 53, 41, 12,\n 57, 42, 27, 31, 40, 18, 56, 22, 37, 48, 30, 35, 36, 37, 32, 35, 49, 35,\n 34, 38, 26, 57, 60, 46, 32, 50, 37, 41, 36, 45, 47, 40, 45, 29, 18, 40,\n 53, 52, 42, 33, 26, 44, 32, 39, 60, 43, 60, 24, 44, 75, 55, 27, 32, 19,\n 20, 42, 21, 41, 41, 47, 34, 46, 55, 38, 35, 49, 36, 45, 34, 22, 41, 68,\n 31, 12, 36, 27, 52, 46, 26, 15, 37, 59, 26, 52, 38, 35, 54, 13, 48, 46,\n 55, 57, 39, 52, 35, 44, 52, 24, 51, 41, 59, 53, 36, 38, 62, 44, 58, 18,\n 41, 44, 44, 26, 38, 35, 42, 49, 52, 37, 33, 46, 56, 42, 44, 47, 63, 24,\n 47, 69, 31, 32, 11, 23, 46, 43, 53, 65, 56, 17, 54, 29, 36, 38, 54, 33,\n 37, 53, 46, 30, 46, 28, 30, 41, 31, 23, 49, 35, 33, 62, 43, 44, 30, 18,\n 52, 57, 38, 42, 30, 42, 44, 44, 39, 46, 50, 44, 27, 61, 29, 31, 33, 41,\n 68, 49, 36, 13, 32, 62, 41, 59, 39, 24, 12, 57, 53, 31, 66, 19, 47, 47,\n 51, 60, 21, 41, 50, 49, 31, 26, 64, 26, 48, 29, 4, 35, 48, 51, 52, 33,\n 23, 26, 60, 44, 55, 23, 44, 41, 47, 52, 26, 13, 75, 12, 53, 43, 54, 40,\n 57, 36, 17, 33, 49, 25, 54, 10, 34, 43, 28, 37, 48, 31, 25, 54, 22, 70,\n 55, 39, 57, 39, 14, 39, 20, 57, 39, 35, 42, 40, 35, 30, 70, 24, 43, 42,\n 28, 43, 13, 32, 19, 42, 53, 63, 31, 44, 19, 41, 29, 51, 30, 61, 45, 43,\n 47, 65, 56, 53, 23, 27, 54, 39, 56, 47, 50, 54, 49, 51, 15, 35, 32, 68,\n 41, 76, 16, 43, 36, 23, 40, 43, 12, 30, 56, 57, 47, 18, 31, 53, 22, 47,\n 21, 39, 47, 43, 29, 51, 29, 39, 36, 54, 24, 30, 62, 36, 70, 16, 46, 24,\n 15, 26, 20, 42, 55, 29, 57, 59, 30, 47, 60, 37, 43, 43, 27, 42, 55, 26,\n 12, 16, 45, 42, 57, 39, 22, 37, 38, 41, 38, 46, 22, 10, 51, 32, 38, 41,\n 17, 17, 28, 35, 43, 25, 51, 35, 45, 67, 42, 18, 41, 35, 77, 30, 20, 46,\n 46, 43, 44, 41, 50, 29, 45, 26, 31, 41, 32, 44, 31, 58, 26, 30, 66, 14,\n 55, 30, 19, 48, 55, 53, 15, 64, 32, 43, 21, 40, 78, 37, 29, 46, 29, 25,\n 40, 67, 32, 53, 29, 48, 28, 48, 26, 70, 53, 52, 47, 19, 22, 44, 49, 48,\n 29, 55, 44, 30, 55, 32, 50, 51, 45, 63, 71, 28, 13, 26, 48, 34, 43, 49,\n 39, 38, 69, 14, 32, 38, 50, 48, 37, 50, 33, 52, 28, 39, 46, 37, 30, 28,\n 28, 32, 35, 24, 38, 33, 36, 52, 37, 27, 32, 15, 41, 36, 53, 23, 33, 11,\n 43, 48, 32, 50, 35, 69, 31, 39, 10, 22, 18, 40, 21, 8, 39, 39, 32, 28,\n 35, 61, 47, 28, 41, 61, 71, 39, 37, 42, 55, 46, 23, 42, 64, 28, 33, 22,\n 65, 26, 35, 26, 23, 22, 53, 51, 50, 22, 50, 49, 28, 15, 48, 58, 53, 51,\n 44, 25, 26, 59, 47, 51, 25, 21, 40, 32, 26, 35, 68, 34, 17, 59, 63, 29,\n 22, 27, 8, 21, 49, 43, 46, 28, 53, 43, 16, 58, 56, 56, 38, 41, 53, 51,\n 58, 50, 52, 31, 44, 26, 36, 52, 38, 14, 31, 40, 24, 52, 58, 37, 56, 43,\n 62, 58, 25, 55, 30, 40, 60, 26, 23, 26, 61, 18, 43, 43, 47, 21, 38, 51,\n 33, 60, 39, 40, 40, 58, 38, 43, 31, 49, 28, 20, 48, 36, 42, 28, 36, 22,\n 62, 19, 52, 28, 47, 51, 58, 56, 32, 29, 75, 55, 32, 40, 34, 47, 57, 49,\n 32, 41, 20, 25, 38, 42, 30, 53, 24, 25, 53, 42, 17, 29, 21, 44, 46, 33,\n 32, 54, 35, 48, 30, 66, 43, 44, 71, 66, 46, 57, 64, 9, 41, 22, 39, 45,\n 43, 33, 26, 46, 41, 34, 32, 66, 18, 40, 22, 52, 29, 73, 31, 36, 36, 50,\n 26, 56, 62, 19, 76, 43, 39, 55, 39, 44, 58, 15, 27, 16, 47, 35, 50, 23,\n 58, 57, 44, 53, 48, 24, 63, 20, 39, 40, 39, 30, 38, 32, 44, 29, 43, 30,\n 49, 45, 45, 42, 69, 16, 26, 57, 36, 37, 56, 47, 15, 57, 64, 36, 50, 42,\n 39, 9, 45, 14, 36, 33, 34, 47, 32, 52, 26, 41, 33, 19, 43, 15, 25, 55,\n 59, 33, 33, 32, 44, 56, 67, 84, 33, 42, 44, 61, 47, 24, 71, 29, 22, 36,\n 33, 41, 19, 36, 24, 51, 36, 29, 26, 26, 35, 28, 38, 49, 58, 35, 47, 31,\n 43, 30, 23, 19, 29, 33, 50, 44, 71, 13, 20, 22, 31, 44, 62, 23, 25, 31,\n 24, 48, 25, 58, 32, 31, 37, 34, 63, 56, 16, 59, 51, 25, 30, 69, 32, 39,\n 50, 55, 28, 37, 87, 35, 70, 52, 33, 41, 47, 9, 52, 55, 32, 59, 47, 79,\n 35, 55, 12, 25, 24, 36, 18, 52, 34, 28, 56, 20, 35, 24, 40, 61, 42, 61,\n 29, 29, 30, 64, 45, 22, 45, 28, 45, 30, 46, 47, 33, 25, 34, 43, 53, 41,\n 20, 43, 60, 49, 46, 55, 50, 32, 45, 33, 62, 14, 57, 54, 35, 26, 58, 36,\n 52, 68, 29, 56, 30, 13, 38, 22, 30, 33, 52, 35, 63, 42, 50, 44, 23, 52,\n 37, 17, 56, 49, 44, 50, 50, 48, 37, 52, 35, 43, 46, 12, 52, 45, 34, 36,\n 22, 46, 51, 50, 33, 34, 35, 25, 28, 71, 33, 34, 10, 19, 20, 42, 39, 73,\n 37, 39, 30, 43, 40, 15, 55, 35, 32, 49, 51, 41, 55, 42, 44, 46, 20, 44,\n 61, 46, 55, 34, 27, 32, 33, 41, 56, 33, 63, 7, 34, 7, 36, 36, 50, 15, 30,\n 45, 29, 39, 62, 30, 66, 37, 40, 61, 35, 25, 64, 20, 38, 29, 17, 23, 41,\n 42, 50, 49, 45, 27, 28, 46, 69, 24, 57, 34, 43, 22, 34, 19, 30, 21, 11,\n 62, 47, 44, 50, 37, 39, 32, 33, 10, 56, 39, 17, 35, 57, 42, 55, 41, 30,\n 38, 27, 44, 28, 31, 36, 52, 17, 12, 37, 47, 48, 20, 55, 47, 38, 62, 48,\n 41, 48, 46, 22, 59, 37, 39, 30, 39, 32, 19, 51, 33, 61, 52, 46, 47, 34,\n 32, 44, 41, 42, 64, 23, 31, 48, 62, 19, 50, 34, 40, 21, 43, 19, 31, 57,\n 37, 52, 69, 49, 45, 28, 35, 23, 21, 35, 27, 41, 58, 8, 20, 41, 37, 46,\n 26, 45, 21, 39, 54, 21, 41, 41, 26, 58, 16, 69, 49, 26, 30, 32, 63, 51,\n 30, 74, 42, 36, 46, 31, 54, 24, 27, 21, 62, 30, 41, 34, 62, 59, 21, 40,\n 22, 29, 69, 31, 17, 36, 44, 36, 65, 49, 52, 52, 22, 51, 35, 55, 28, 43,\n 28, 45, 28, 48, 49, 47, 41, 34, 60, 28, 45, 32, 77, 44, 36, 25, 58, 17,\n 50, 51, 39, 40, 9, 52, 21, 15, 41, 34, 49, 57, 28, 21, 47, 26, 68, 47,\n 13, 54, 49, 26, 63, 34, 52, 35, 28, 7, 46, 63, 17, 20, 32, 27, 42, 17,\n 55, 50, 14, 33, 45, 36, 15, 10, 46, 25, 41, 49, 67, 20, 27, 49, 28, 36,\n 68, 37, 34, 59, 44, 55, 34, 69, 51, 56, 36, 30, 63, 60, 84, 48, 44, 44,\n 47, 34, 58, 45, 39, 23, 33, 39, 85, 64, 56, 42, 46, 43, 35, 32, 55, 28,\n 46, 23, 58, 28, 31, 54, 52, 31, 48, 35, 50, 24, 35, 54, 13, 10, 23, 51,\n 38, 24, 53, 3, 18, 34, 55, 54, 23, 42, 54, 12, 36, 50, 39, 43, 29, 38,\n 36, 41, 40, 36, 32, 29, 46, 37, 69, 36, 36, 50, 40, 28, 21, 45, 42, 16,\n 49, 50, 36, 37, 24, 30, 32, 29, 36, 20, 57, 16, 25, 53, 49, 23, 51, 40,\n 22, 59, 32, 45, 40, 31, 44, 39, 26, 29, 38, 60, 41, 71, 39, 37, 20, 26,\n 39, 32, 40, 45, 43, 67, 32, 45, 53, 29, 54, 36, 41, 33, 24, 57, 51, 55,\n 40, 64, 25, 27, 20, 18, 31, 43, 18, 24, 30, 25, 48, 53, 18, 39, 37, 54,\n 25, 35, 31, 35, 34, 30, 44, 12, 45, 31, 44, 38, 17, 50, 31, 31, 37, 42,\n 43, 33, 35, 22, 26, 48, 47, 33, 58, 29, 53, 31, 27, 66, 6, 60, 46, 36,\n 27, 66, 54, 57, 71, 5, 12, 42, 42, 15, 28, 43, 71, 21, 53, 48, 33, 27,\n 55, 14, 51, 34, 17, 53, 30, 32, 37, 59, 39, 29, 64, 50, 48, 51, 32, 28,\n 29, 32, 49, 18, 58, 49, 46, 35, 50, 40, 48, 33, 27, 35, 51, 38, 51, 57,\n 14, 78, 34, 18, 33, 33, 35, 45, 34, 40, 12, 25, 53, 56, 27, 31, 40, 27,\n 48, 68, 48, 29, 42, 19, 38, 53, 33, 19, 54, 17, 27, 42, 69, 60, 37, 65,\n 57, 55, 65, 48, 42, 76, 23, 26, 64, 52, 55, 6, 27, 26, 29, 30, 26, 64,\n 50, 59, 54, 58, 34, 47, 42, 50, 55, 53, 24, 28, 21, 51, 39, 56, 37, 49,\n 37, 56, 37, 58, 49, 39, 61, 40, 41, 19, 50, 65, 50, 53, 45, 54, 20, 30,\n 29, 27, 53, 37, 56, 24, 37, 54, 46, 18, 11, 43, 19, 34, 22, 27, 29, 35,\n 48, 56, 48, 53, 27, 38, 39, 26, 33, 15, 62, 28, 56, 43, 31, 15, 45, 50,\n 23, 49, 27, 57, 25, 36, 32, 54, 60, 38, 33, 28, 32, 49, 34, 14, 27, 58,\n 20, 21, 23, 43, 38, 29, 52, 78, 41, 63, 50, 38, 36, 39, 65, 36, 38, 61,\n 59, 47, 45, 17, 57, 24, 69, 74, 23, 50, 32, 35, 55, 42, 54, 47, 29, 52,\n 42, 27, 12, 60, 11, 33, 28, 48, 38, 25, 45, 59, 28, 61, 42, 33, 29, 27,\n 64, 20, 27, 15, 56, 15, 64, 34, 41, 27, 77, 52, 51, 36, 40, 43, 59, 23,\n 19, 49, 44, 47, 45, 37, 38, 39, 31, 35, 41, 18, 55, 38, 60, 38, 20, 52,\n 21, 26, 49, 73, 35, 29, 32, 29, 17, 47, 31, 38, 36, 31, 33, 22, 14, 17,\n 44, 72, 54, 58, 32, 49, 29, 28, 50, 62, 42, 35, 30, 22, 35, 29, 40, 43,\n 42, 50, 33, 42, 61, 42, 40, 34, 44, 30, 15, 64, 48, 35, 25, 44, 41, 53,\n 26, 46, 61, 38, 20, 39, 63, 24, 34, 52, 17, 30, 41, 45, 40, 55, 56, 27,\n 44, 31, 23, 24, 52, 39, 24, 51, 46, 60, 27, 52, 34, 62, 22, 48, 58, 38,\n 39, 60, 72, 24, 51, 51, 12, 48, 7, 20, 19, 46, 27, 45, 21, 31, 34, 35,\n 50, 6, 40, 45, 47, 42, 37, 24, 66, 43, 39, 40, 64, 30, 48, 9, 47, 47, 59,\n 40, 34, 46, 33, 45, 44, 49, 34, 56, 48, 31, 39, 58, 62, 30, 24, 42, 28,\n 59, 57, 61, 38, 60, 35, 23, 46, 46, 40, 44, 43, 38, 34, 51, 49, 49, 39,\n 37, 21, 74, 48, 80, 39, 30, 23, 53, 48, 42, 20, 44, 35, 53, 34, 52, 14,\n 32, 73, 36, 24, 41, 42, 46, 39, 35, 40, 18, 14, 34, 27, 38, 54, 28, 29,\n 41, 71, 18, 48, 41, 32, 34, 13, 37, 24, 23, 38, 47, 42, 47, 53, 38, 31,\n 9, 37, 59, 33, 29, 67, 9, 27, 44, 53, 13, 29, 38, 52, 32, 31, 22, 54, 43,\n 42, 20, 32, 43, 17, 60, 17, 38, 40, 25, 67, 50, 40, 16, 72, 41, 43, 12,\n 47, 10, 34, 31, 28, 43, 63, 55, 42, 17, 31, 62, 53, 19, 22, 28, 46, 42,\n 29, 76, 17, 21, 41, 31, 32, 42, 43, 43, 24, 36, 59, 5, 60, 37, 18, 46, 9,\n 48, 53, 51, 60, 40, 21, 9, 19, 38, 44, 32, 41, 30, 43, 52, 26, 20, 46,\n 37, 40, 54, 40, 36, 10, 29, 54, 56, 19, 35, 59, 33, 42, 39, 32, 50, 31,\n 33, 57, 15, 32, 34, 41, 55, 43, 55, 59, 41, 69, 32, 34, 21, 34, 32, 43,\n 55, 27, 28, 49, 22, 34, 37, 36, 39, 58, 42, 45, 50, 14, 39, 56, 46, 73,\n 21, 29, 37, 34, 56, 55, 37, 44, 49, 40, 51, 64, 64, 62, 60, 10, 43, 34,\n 43, 20, 31, 44, 41, 40, 29, 57, 68, 47, 44, 28, 27, 34, 53, 49, 48, 38,\n 51, 25, 15, 31, 28, 42, 50, 37, 33, 38, 24, 36, 29, 38, 65, 48, 60, 40,\n 40, 42, 10, 36, 36, 46, 64, 45, 38, 51, 20, 45, 39, 38, 44, 12, 61, 27,\n 44, 62, 50, 69, 57, 58, 53, 31, 56, 29, 39, 21, 35, 40, 29, 36, 28, 56,\n 15, 55, 59, 50, 46, 8, 38, 54, 15, 46, 29, 59, 56, 52, 33, 34, 74, 34,\n 38, 43, 25, 37, 42, 40, 64, 58, 31, 28, 47, 21, 60, 54, 62, 70, 27, 44,\n 17, 25, 35, 7, 58, 6, 68, 39, 37, 4, 44, 30, 41, 12, 42, 24, 31, 24, 58,\n 48, 37, 38, 44, 43, 45, 42, 31, 17, 41, 52, 55, 45, 24, 5, 56, 73, 25,\n 30, 36, 59, 24, 46, 18, 57, 30, 31, 34, 40, 61, 46, 49, 40, 44, 45, 20,\n 43, 33, 42, 38, 54, 10, 39, 42, 40, 12, 48, 36, 32, 33, 43, 38, 28, 28,\n 18, 61, 27, 23, 37, 51, 31, 30, 46, 22, 32, 27, 36, 44, 79, 45, 50, 44,\n 6, 33, 28, 31, 15, 36, 54, 43, 51, 51, 21, 57, 21, 24, 17, 53, 38, 41,\n 37, 18, 21, 27, 43, 42, 20, 18, 55, 21, 36, 43, 26, 38, 46, 44, 50, 27,\n 19, 45, 45, 39, 25, 56, 27, 45, 55, 36, 37, 30, 30, 27, 38, 44, 52, 30,\n 48, 42, 29, 27, 24, 14, 38, 18, 38, 52, 36, 17, 37, 53, 59, 61, 12, 27,\n 36, 24, 16, 22, 31, 55, 45, 54, 45, 51, 29, 32, 33, 46, 30, 49, 51, 47,\n 71, 52, 33, 12, 36, 39, 33, 53, 43, 32, 76, 39, 25, 31, 28, 14, 40, 70,\n 35, 30, 51, 44, 47, 39, 48, 43, 33, 37, 12, 34, 62, 46, 36, 44, 25, 69,\n 36, 24, 13, 34, 45, 28, 47, 27, 58, 14, 36, 45, 36, 35, 20, 55, 14, 29,\n 50, 50, 33, 28, 24, 38, 26, 68, 55, 20, 33, 47, 56, 67, 48, 39, 37, 50,\n 51, 29, 20, 34, 33, 53, 45, 28, 51, 50, 39, 53, 50, 58, 46, 43, 16, 31,\n 50, 71, 40, 41, 66, 40, 33, 38, 48, 52, 11, 28, 29, 49, 56, 23, 46, 51,\n 58, 49, 33, 47, 28, 41, 51, 25, 45, 41, 28, 39, 54, 41, 28, 26, 35, 33,\n 56, 45, 39, 27, 40, 48, 25, 40, 51, 51, 33, 32, 41, 10, 41, 55, 43, 26,\n 28, 50, 46, 29, 35, 19, 27, 28, 55, 36, 57, 64, 44, 34, 34, 32, 26, 30,\n 36, 20, 40, 6, 37, 33, 49, 68, 45, 34, 54, 52, 48, 65, 37, 35, 32, 48,\n 41, 48, 32, 43, 26, 41, 35, 41, 62, 35, 26, 45, 31, 30, 37, 23, 68, 40,\n 16, 28, 28, 24, 39, 46, 12, 40, 45, 44, 35, 53, 38, 42, 27, 32, 39, 53,\n 18, 30, 45, 58, 42, 36, 67, 24, 36, 38, 9, 56, 61, 47, 60, 58, 66, 14,\n 35, 32, 32, 58, 38, 40, 37, 38, 44, 57, 34, 75, 44, 33, 29, 53, 44, 32,\n 40, 35, 55, 13, 35, 52, 31, 47, 16, 35, 56, 39, 33, 46, 47, 24, 46, 21,\n 35, 35, 17, 31, 39, 39, 36, 17, 29, 42, 33, 29, 54, 56, 24, 28, 48, 15,\n 44, 35, 35, 39, 60, 42, 48, 43, 58, 36, 46, 30, 45, 40, 63, 42, 15, 54,\n 34, 30, 54, 34, 21, 19, 25, 21, 19, 47, 28, 58, 28, 11, 29, 36, 30, 56,\n 31, 38, 29, 48, 36, 34, 45, 35, 39, 55, 10, 31, 72, 44, 31, 44, 34, 15,\n 39, 5, 35, 35, 50, 66, 45, 50, 47, 40, 20, 22, 50, 34, 46, 55, 44, 55,\n 62, 38, 46, 45, 52, 27, 51, 33, 29, 16, 40, 37, 62, 37, 46, 26, 37, 47,\n 26, 39, 36, 35, 31, 48, 19, 41, 56, 44, 54, 67, 36, 27, 39, 31, 46, 19,\n 50, 29, 48, 28, 52, 49, 30, 39, 53, 54, 20, 29, 48, 40, 44, 49, 53, 19,\n 23, 33, 32, 47, 36, 42, 38, 24, 13, 52, 45, 52, 46, 59, 18, 31, 37, 35,\n 22, 26, 9, 12, 20, 36, 10, 41, 31, 48, 42, 44, 29, 38, 53, 27, 50, 46,\n 64, 22, 30, 37, 24, 50, 52, 32, 43, 51, 78, 70, 62, 34, 58, 27, 61, 27,\n 54, 59, 48, 42, 58, 67, 50, 24, 42, 30, 29, 36, 52, 53, 27, 20, 38, 9,\n 29, 17, 34, 26, 8, 32, 52, 27, 31, 35, 31, 23, 50, 24, 41, 67, 44, 69,\n 21, 30, 58, 33, 32, 44, 53, 41, 41, 40, 15, 48, 56, 39, 37, 59, 20, 61,\n 38, 44, 23, 28, 32, 54, 29, 33, 46, 42, 63, 58, 47, 37, 32, 12, 39, 46,\n 13, 56, 68, 49, 59, 35, 23, 13, 47, 27, 69, 4, 49, 35, 60, 41, 5, 28, 67,\n 51, 42, 45, 28, 36, 42, 52, 50, 46, 36, 35, 17, 33, 20, 23, 53, 38, 39,\n 43, 29, 37, 55, 44, 32, 35, 20, 63, 51, 39, 50, 30, 27, 80, 18, 53, 54,\n 51, 53, 39, 32, 63, 10, 31, 32, 39, 38, 44, 30, 37, 40, 44, 43, 30, 20,\n 44, 58, 70, 65, 54, 47, 40, 54, 36, 46, 48, 54, 31, 29, 47, 48, 27, 46,\n 24, 40, 50, 28, 50, 31, 19, 50, 61, 37, 36, 47, 25, 67, 31, 38, 19, 39,\n 25, 14, 76, 34, 52, 22, 55, 47, 20, 39, 34, 54, 40, 44, 59, 48, 41, 50,\n 29, 25, 42, 64, 38, 23, 55, 27, 40, 47, 24, 34, 66, 31, 56, 10, 46, 43,\n 45, 30, 48, 15, 28, 43, 50, 16, 35, 28, 45, 40, 38, 48, 16, 26, 30, 26,\n 30, 68, 67, 53, 44, 45, 51, 47, 45, 29, 45, 46, 46, 75, 21, 28, 30, 35,\n 44, 45, 42, 48, 33, 52, 49, 53, 39, 36, 25, 49, 45, 17, 20, 61, 18, 29,\n 68, 50, 47, 28, 41, 26, 36, 40, 16, 46, 26, 38, 37, 59, 56, 18, 57, 33,\n 65, 44, 42, 37, 55, 38, 46, 8, 16, 51, 27, 51, 54, 27, 12, 10, 48, 70,\n 19, 39, 39, 28, 36, 23, 33, 32, 31, 24, 7, 37, 21, 31, 36, 46, 21, 51,\n 61, 54, 24, 36, 74, 40, 49, 25, 40, 46, 19, 28, 44, 58, 10, 34, 43, 45,\n 30, 36, 48, 33, 50, 43, 50, 35, 16, 40, 36, 38, 35, 54, 37, 40, 42, 14,\n 35, 41, 47, 51, 50, 61, 36, 58, 30, 46, 44, 38, 20, 11, 34, 42, 59, 38,\n 71, 40, 25, 35, 52, 26, 66, 49, 36, 31, 24, 52, 58, 60, 7, 31, 49, 35,\n 61, 56, 46, 32, 19, 78, 35]},\n 'test_3': {'capacity': 100, 'num_items': 5000,\n 'items': [55, 51, 16, 43, 30, 49, 52, 44, 48, 29, 52, 34, 37, 25, 53, 48, 33, 34,\n 37, 72, 42, 46, 13, 64, 42, 66, 60, 37, 27, 48, 32, 46, 41, 36, 52, 22,\n 17, 30, 32, 37, 39, 35, 43, 55, 49, 23, 43, 66, 36, 42, 30, 37, 29, 44,\n 29, 48, 51, 47, 60, 51, 40, 36, 55, 60, 42, 60, 54, 20, 28, 43, 46, 41,\n 39, 36, 22, 23, 22, 44, 44, 41, 35, 50, 17, 30, 24, 46, 32, 66, 39, 54,\n 34, 24, 41, 49, 37, 41, 5, 34, 49, 44, 24, 44, 20, 31, 46, 32, 86, 31,\n 48, 38, 49, 16, 46, 58, 18, 41, 26, 61, 48, 51, 16, 48, 30, 48, 21, 34,\n 13, 37, 59, 30, 34, 68, 59, 36, 28, 19, 61, 50, 14, 44, 43, 18, 48, 69,\n 55, 63, 69, 69, 25, 55, 44, 55, 29, 63, 50, 47, 37, 40, 35, 25, 25, 34,\n 49, 30, 40, 34, 47, 43, 65, 69, 47, 67, 36, 56, 18, 16, 34, 48, 31, 13,\n 61, 42, 24, 52, 42, 35, 37, 33, 17, 21, 49, 57, 47, 27, 25, 52, 20, 20,\n 36, 40, 46, 44, 59, 46, 47, 54, 38, 65, 68, 54, 47, 36, 61, 25, 53, 34,\n 21, 54, 61, 27, 31, 50, 42, 43, 25, 29, 32, 26, 26, 37, 33, 29, 30, 64,\n 37, 52, 43, 43, 47, 59, 37, 38, 33, 66, 34, 32, 53, 14, 67, 10, 35, 58,\n 50, 23, 36, 46, 52, 34, 48, 24, 28, 47, 49, 19, 60, 20, 23, 18, 34, 32,\n 62, 31, 50, 53, 26, 53, 27, 39, 40, 61, 48, 41, 40, 32, 33, 42, 30, 31,\n 50, 19, 36, 64, 46, 36, 29, 55, 49, 43, 42, 62, 47, 36, 49, 47, 27, 59,\n 24, 46, 40, 48, 35, 39, 62, 31, 67, 37, 15, 10, 17, 66, 48, 35, 24, 36,\n 41, 17, 34, 43, 70, 44, 55, 50, 35, 42, 14, 33, 63, 12, 62, 56, 60, 17,\n 26, 45, 62, 68, 24, 66, 24, 52, 27, 12, 68, 43, 41, 38, 75, 65, 51, 63,\n 20, 24, 32, 46, 41, 32, 51, 64, 60, 11, 59, 54, 47, 60, 26, 38, 76, 15,\n 46, 7, 25, 57, 23, 32, 34, 26, 25, 38, 59, 45, 38, 33, 31, 37, 37, 44,\n 46, 21, 22, 52, 29, 19, 39, 41, 39, 31, 51, 32, 23, 21, 30, 49, 64, 28,\n 49, 19, 48, 19, 49, 16, 34, 46, 61, 13, 45, 39, 36, 36, 32, 40, 29, 54,\n 34, 37, 38, 65, 27, 28, 38, 46, 34, 38, 50, 54, 34, 39, 39, 21, 38, 44,\n 21, 52, 59, 33, 69, 38, 54, 13, 44, 52, 32, 28, 44, 43, 58, 21, 52, 35,\n 42, 34, 49, 39, 26, 69, 25, 37, 49, 54, 56, 65, 43, 32, 36, 27, 40, 23,\n 48, 24, 13, 25, 38, 29, 40, 26, 36, 50, 47, 25, 59, 24, 45, 28, 41, 23,\n 55, 44, 49, 64, 14, 49, 13, 12, 14, 61, 37, 63, 45, 17, 33, 27, 32, 15,\n 48, 54, 28, 36, 24, 45, 43, 26, 55, 29, 60, 53, 30, 87, 48, 51, 47, 54,\n 38, 53, 51, 25, 48, 12, 30, 36, 80, 63, 30, 33, 38, 33, 32, 24, 12, 29,\n 41, 26, 64, 37, 24, 83, 27, 62, 52, 45, 23, 39, 37, 51, 52, 48, 23, 34,\n 51, 27, 41, 50, 52, 73, 23, 38, 38, 25, 36, 52, 79, 21, 42, 60, 68, 48,\n 23, 15, 33, 39, 50, 23, 39, 64, 51, 16, 27, 41, 70, 50, 34, 29, 44, 18,\n 63, 47, 14, 36, 45, 69, 71, 42, 11, 49, 10, 43, 31, 48, 54, 31, 40, 35,\n 40, 38, 33, 46, 43, 34, 26, 49, 8, 46, 11, 27, 27, 11, 64, 47, 37, 41,\n 68, 28, 31, 69, 36, 40, 45, 49, 55, 35, 46, 44, 66, 50, 53, 37, 30, 66,\n 14, 63, 39, 45, 42, 37, 48, 55, 54, 32, 18, 64, 39, 49, 68, 35, 40, 16,\n 51, 51, 41, 54, 41, 27, 17, 40, 36, 54, 58, 36, 46, 29, 34, 35, 18, 41,\n 59, 49, 44, 36, 50, 29, 36, 15, 58, 30, 15, 46, 26, 30, 62, 50, 35, 19,\n 35, 20, 32, 19, 69, 19, 40, 51, 51, 53, 17, 38, 40, 10, 43, 22, 72, 33,\n 70, 14, 48, 38, 50, 42, 21, 28, 36, 44, 67, 34, 22, 17, 18, 28, 49, 66,\n 26, 53, 41, 21, 8, 26, 39, 54, 45, 42, 28, 49, 62, 66, 41, 36, 41, 32,\n 31, 20, 42, 26, 39, 37, 29, 29, 21, 41, 26, 36, 57, 44, 45, 26, 42, 44,\n 45, 47, 61, 51, 27, 22, 44, 44, 25, 7, 36, 21, 53, 26, 38, 26, 28, 60,\n 57, 28, 65, 64, 33, 34, 29, 26, 48, 42, 46, 21, 31, 62, 58, 47, 56, 42,\n 50, 52, 41, 23, 28, 64, 11, 46, 36, 56, 44, 58, 58, 29, 13, 68, 46, 45,\n 15, 29, 53, 51, 58, 27, 35, 47, 39, 48, 34, 26, 36, 54, 60, 56, 67, 40,\n 39, 63, 47, 44, 24, 58, 48, 48, 49, 46, 41, 68, 42, 50, 73, 23, 23, 36,\n 41, 43, 20, 63, 36, 20, 39, 49, 25, 32, 53, 21, 31, 54, 30, 22, 28, 37,\n 57, 37, 41, 42, 21, 14, 48, 22, 49, 39, 21, 36, 19, 31, 64, 50, 12, 32,\n 58, 45, 35, 21, 49, 58, 69, 48, 37, 27, 44, 32, 20, 24, 35, 49, 54, 19,\n 53, 40, 49, 67, 26, 49, 70, 43, 30, 38, 27, 35, 57, 39, 45, 38, 41, 15,\n 21, 54, 26, 34, 46, 64, 36, 28, 45, 63, 57, 67, 22, 26, 8, 42, 47, 36,\n 66, 23, 42, 24, 16, 37, 39, 57, 54, 26, 33, 17, 21, 66, 26, 32, 35, 54,\n 40, 19, 59, 41, 45, 34, 45, 31, 32, 20, 35, 50, 24, 41, 93, 47, 30, 45,\n 32, 45, 37, 40, 67, 32, 14, 28, 41, 62, 34, 28, 33, 28, 41, 61, 37, 46,\n 23, 32, 33, 39, 37, 49, 36, 32, 61, 27, 68, 62, 52, 40, 39, 46, 23, 49,\n 17, 38, 31, 23, 17, 25, 70, 47, 46, 50, 15, 34, 56, 51, 48, 74, 27, 64,\n 11, 51, 46, 37, 35, 51, 23, 35, 36, 31, 55, 32, 33, 49, 12, 39, 48, 20,\n 35, 58, 70, 36, 52, 21, 46, 32, 41, 42, 42, 13, 14, 44, 31, 51, 47, 21,\n 45, 43, 38, 44, 44, 32, 54, 30, 51, 36, 8, 44, 14, 28, 35, 34, 40, 28,\n 16, 49, 21, 33, 39, 48, 65, 38, 58, 38, 35, 41, 36, 77, 33, 38, 29, 23,\n 20, 59, 38, 30, 32, 25, 27, 28, 45, 43, 42, 23, 20, 37, 29, 49, 51, 10,\n 73, 12, 33, 30, 21, 48, 38, 48, 46, 31, 37, 35, 26, 67, 21, 66, 55, 43,\n 26, 49, 52, 39, 33, 59, 33, 25, 54, 55, 16, 19, 34, 49, 42, 44, 26, 32,\n 40, 25, 53, 33, 36, 61, 66, 55, 78, 54, 31, 44, 40, 25, 31, 65, 57, 50,\n 25, 17, 52, 23, 50, 24, 54, 28, 56, 26, 41, 46, 43, 43, 46, 39, 26, 26,\n 40, 59, 31, 24, 30, 14, 53, 34, 54, 34, 46, 66, 51, 52, 56, 30, 45, 38,\n 22, 49, 55, 40, 24, 54, 41, 44, 38, 39, 40, 15, 7, 76, 42, 53, 44, 39,\n 39, 41, 38, 53, 23, 52, 44, 28, 62, 41, 69, 43, 60, 37, 33, 37, 69, 38,\n 49, 35, 37, 29, 22, 37, 52, 40, 40, 20, 18, 30, 39, 49, 10, 9, 62, 47,\n 46, 27, 79, 43, 37, 34, 57, 56, 45, 42, 44, 47, 21, 27, 59, 36, 17, 39,\n 45, 69, 28, 28, 48, 20, 47, 48, 60, 31, 56, 43, 54, 19, 19, 59, 67, 23,\n 48, 52, 26, 50, 18, 70, 22, 15, 42, 39, 29, 64, 23, 57, 24, 31, 12, 25,\n 20, 54, 49, 65, 60, 41, 32, 45, 41, 57, 54, 35, 16, 27, 54, 55, 71, 33,\n 21, 51, 39, 45, 29, 36, 28, 7, 8, 34, 38, 26, 33, 81, 62, 15, 31, 19, 42,\n 25, 47, 53, 45, 49, 52, 33, 42, 34, 59, 54, 45, 54, 31, 47, 52, 42, 26,\n 46, 36, 41, 54, 31, 52, 60, 42, 41, 47, 43, 19, 54, 17, 31, 34, 77, 49,\n 12, 27, 36, 61, 31, 47, 45, 53, 48, 44, 18, 45, 51, 21, 32, 20, 38, 32,\n 15, 35, 45, 34, 38, 35, 48, 60, 61, 37, 54, 26, 74, 56, 22, 38, 20, 24,\n 42, 26, 48, 58, 61, 45, 40, 48, 50, 25, 36, 67, 44, 52, 30, 69, 35, 39,\n 46, 65, 76, 41, 45, 28, 34, 41, 27, 61, 51, 18, 34, 45, 20, 29, 54, 27,\n 32, 65, 16, 27, 47, 25, 17, 38, 38, 35, 34, 22, 34, 36, 15, 49, 47, 78,\n 20, 28, 26, 42, 34, 32, 38, 42, 50, 32, 47, 37, 32, 52, 39, 30, 29, 58,\n 27, 25, 38, 50, 49, 39, 50, 43, 27, 55, 49, 49, 58, 31, 18, 41, 49, 49,\n 31, 12, 41, 68, 51, 83, 22, 38, 39, 65, 35, 17, 49, 28, 21, 19, 53, 40,\n 44, 67, 49, 17, 25, 31, 24, 29, 41, 26, 35, 38, 36, 61, 38, 37, 13, 49,\n 58, 37, 32, 57, 46, 39, 38, 25, 47, 17, 50, 33, 51, 44, 47, 47, 35, 42,\n 47, 50, 31, 46, 11, 28, 52, 22, 31, 50, 54, 22, 39, 36, 29, 34, 34, 60,\n 47, 29, 40, 49, 26, 51, 26, 52, 39, 49, 14, 52, 19, 34, 48, 39, 14, 57,\n 40, 49, 16, 68, 45, 30, 29, 55, 40, 42, 43, 33, 61, 38, 40, 23, 9, 47,\n 59, 38, 38, 39, 30, 59, 45, 81, 48, 62, 22, 40, 20, 46, 19, 62, 56, 40,\n 34, 35, 34, 26, 40, 34, 26, 48, 37, 22, 45, 26, 38, 13, 21, 37, 37, 31,\n 56, 47, 17, 42, 12, 35, 58, 29, 40, 39, 34, 25, 50, 49, 10, 58, 62, 28,\n 84, 47, 41, 48, 62, 54, 49, 53, 58, 33, 52, 43, 27, 29, 53, 81, 52, 31,\n 23, 37, 50, 68, 28, 30, 14, 39, 55, 44, 40, 37, 28, 31, 42, 40, 51, 45,\n 58, 67, 36, 39, 34, 26, 61, 49, 57, 51, 42, 26, 63, 46, 41, 58, 13, 49,\n 39, 43, 49, 23, 43, 51, 51, 20, 47, 15, 55, 72, 18, 21, 25, 37, 49, 39,\n 45, 52, 39, 73, 31, 38, 36, 36, 29, 33, 33, 21, 22, 36, 41, 65, 69, 28,\n 28, 26, 59, 26, 41, 35, 14, 22, 44, 43, 40, 34, 54, 29, 36, 50, 37, 44,\n 48, 26, 44, 64, 32, 48, 46, 50, 37, 45, 40, 11, 31, 14, 32, 42, 40, 36,\n 34, 36, 48, 29, 16, 48, 55, 54, 58, 32, 35, 55, 28, 43, 24, 38, 52, 34,\n 34, 20, 63, 31, 57, 38, 31, 27, 51, 34, 18, 60, 47, 55, 39, 41, 39, 27,\n 39, 67, 57, 41, 21, 13, 39, 42, 28, 33, 32, 31, 57, 18, 50, 32, 16, 42,\n 44, 15, 31, 51, 48, 15, 22, 40, 29, 26, 14, 51, 38, 39, 40, 21, 52, 59,\n 23, 38, 26, 45, 32, 61, 40, 51, 35, 44, 53, 38, 49, 29, 26, 21, 37, 20,\n 54, 29, 56, 28, 75, 29, 47, 59, 36, 24, 31, 32, 51, 43, 45, 72, 44, 30,\n 62, 39, 30, 36, 37, 33, 31, 32, 39, 30, 64, 46, 25, 22, 70, 45, 30, 62,\n 67, 61, 40, 9, 41, 5, 30, 52, 32, 38, 8, 13, 67, 27, 40, 36, 36, 38, 31,\n 27, 39, 33, 72, 56, 41, 64, 51, 62, 21, 36, 51, 30, 36, 29, 33, 17, 43,\n 18, 38, 24, 59, 30, 36, 15, 27, 45, 14, 47, 29, 36, 51, 58, 45, 49, 61,\n 37, 45, 38, 58, 30, 58, 52, 29, 65, 38, 43, 18, 30, 28, 41, 42, 11, 51,\n 22, 57, 38, 54, 36, 55, 38, 29, 46, 35, 27, 26, 56, 47, 27, 29, 22, 38,\n 13, 24, 32, 42, 32, 50, 46, 35, 24, 41, 54, 43, 47, 36, 37, 30, 48, 34,\n 55, 38, 35, 75, 28, 12, 57, 39, 21, 18, 33, 17, 26, 48, 68, 55, 50, 50,\n 30, 45, 26, 37, 52, 53, 22, 73, 54, 39, 24, 26, 27, 23, 38, 41, 48, 47,\n 30, 36, 22, 38, 27, 26, 33, 58, 70, 68, 8, 29, 9, 19, 17, 32, 42, 50, 60,\n 43, 51, 25, 30, 56, 22, 70, 52, 26, 22, 53, 47, 23, 19, 61, 46, 39, 47,\n 11, 39, 29, 37, 70, 52, 41, 37, 36, 51, 33, 29, 41, 46, 44, 24, 24, 58,\n 11, 53, 34, 44, 53, 39, 52, 74, 16, 53, 46, 38, 71, 57, 26, 38, 54, 54,\n 40, 47, 81, 31, 52, 29, 29, 52, 64, 30, 63, 40, 26, 42, 56, 55, 36, 37,\n 19, 40, 51, 29, 51, 57, 45, 31, 57, 32, 27, 39, 42, 31, 23, 42, 27, 48,\n 31, 35, 25, 52, 58, 62, 6, 80, 29, 72, 54, 43, 48, 29, 50, 49, 19, 53,\n 48, 36, 35, 35, 9, 55, 37, 20, 56, 46, 50, 13, 48, 13, 18, 41, 52, 35,\n 33, 43, 39, 25, 31, 41, 32, 55, 28, 41, 43, 15, 66, 16, 47, 18, 40, 25,\n 27, 45, 39, 30, 43, 52, 44, 24, 74, 45, 36, 28, 46, 43, 7, 27, 48, 44,\n 80, 39, 46, 39, 31, 34, 29, 19, 8, 36, 37, 12, 43, 54, 20, 22, 31, 28,\n 45, 19, 40, 47, 44, 54, 32, 20, 39, 51, 61, 42, 33, 72, 38, 30, 48, 28,\n 36, 32, 31, 59, 38, 37, 67, 68, 14, 20, 33, 59, 44, 35, 18, 49, 53, 63,\n 27, 45, 41, 38, 35, 42, 13, 34, 23, 26, 64, 21, 24, 55, 42, 52, 35, 26,\n 24, 33, 29, 51, 50, 21, 42, 58, 48, 25, 34, 46, 21, 44, 29, 42, 43, 55,\n 48, 38, 54, 27, 38, 29, 29, 40, 51, 20, 66, 29, 39, 41, 23, 54, 27, 37,\n 44, 29, 40, 52, 18, 35, 25, 31, 41, 22, 28, 22, 55, 55, 27, 17, 69, 75,\n 33, 32, 65, 34, 60, 40, 39, 36, 21, 36, 59, 10, 44, 16, 41, 25, 11, 30,\n 33, 40, 63, 27, 38, 56, 49, 49, 33, 30, 26, 61, 28, 26, 48, 37, 42, 46,\n 25, 50, 21, 33, 78, 26, 19, 36, 34, 40, 33, 42, 50, 35, 33, 52, 46, 46,\n 28, 23, 55, 26, 30, 31, 42, 40, 63, 63, 43, 32, 42, 32, 13, 37, 53, 42,\n 22, 51, 61, 18, 25, 20, 36, 20, 36, 19, 41, 30, 64, 57, 38, 35, 31, 40,\n 46, 45, 31, 42, 24, 37, 33, 28, 53, 9, 35, 20, 30, 9, 49, 30, 52, 51, 61,\n 41, 11, 29, 37, 50, 49, 32, 50, 72, 49, 58, 32, 45, 30, 19, 30, 52, 16,\n 41, 38, 41, 41, 33, 22, 31, 44, 57, 24, 67, 52, 29, 29, 10, 56, 60, 76,\n 33, 69, 26, 32, 62, 18, 20, 38, 16, 50, 30, 31, 36, 40, 46, 26, 75, 34,\n 46, 34, 61, 28, 65, 37, 30, 62, 65, 35, 50, 27, 51, 43, 34, 32, 22, 41,\n 30, 35, 30, 60, 44, 50, 46, 26, 27, 39, 62, 23, 25, 36, 41, 50, 35, 36,\n 21, 28, 18, 58, 22, 11, 27, 26, 41, 36, 30, 60, 37, 64, 29, 56, 21, 44,\n 33, 49, 49, 53, 38, 41, 24, 60, 38, 26, 60, 9, 54, 42, 23, 46, 77, 23,\n 42, 37, 30, 23, 15, 26, 35, 21, 25, 39, 45, 28, 58, 52, 26, 34, 55, 59,\n 11, 21, 7, 57, 17, 28, 41, 54, 29, 38, 39, 29, 19, 39, 45, 52, 54, 40,\n 38, 22, 42, 46, 35, 29, 20, 35, 21, 42, 40, 32, 50, 27, 48, 68, 25, 44,\n 42, 64, 35, 77, 15, 32, 32, 31, 45, 52, 14, 63, 48, 17, 45, 37, 16, 21,\n 13, 39, 26, 29, 49, 24, 41, 39, 43, 41, 35, 34, 21, 39, 37, 23, 28, 51,\n 51, 27, 33, 36, 40, 49, 39, 40, 50, 41, 62, 49, 59, 39, 48, 49, 16, 39,\n 51, 47, 32, 51, 27, 36, 39, 28, 50, 27, 28, 18, 36, 37, 28, 23, 27, 15,\n 60, 49, 29, 13, 24, 32, 36, 51, 23, 27, 70, 13, 28, 57, 19, 61, 27, 60,\n 23, 46, 39, 43, 22, 69, 42, 30, 39, 9, 17, 53, 27, 45, 52, 29, 7, 13, 45,\n 45, 47, 36, 65, 49, 59, 41, 33, 26, 65, 21, 23, 19, 48, 27, 56, 38, 57,\n 47, 42, 63, 45, 33, 15, 22, 14, 15, 30, 51, 38, 39, 41, 48, 31, 39, 61,\n 29, 75, 47, 35, 58, 50, 26, 40, 53, 65, 53, 43, 44, 56, 45, 60, 40, 22,\n 33, 59, 53, 47, 56, 67, 47, 46, 45, 34, 75, 48, 29, 62, 24, 34, 36, 55,\n 31, 67, 17, 36, 29, 51, 41, 33, 25, 48, 38, 16, 63, 46, 43, 46, 45, 35,\n 45, 77, 35, 28, 66, 51, 20, 41, 36, 23, 65, 40, 37, 30, 51, 23, 38, 15,\n 63, 47, 37, 24, 18, 28, 42, 27, 44, 36, 46, 43, 41, 46, 57, 49, 43, 40,\n 44, 53, 23, 33, 63, 30, 32, 36, 47, 43, 35, 7, 67, 48, 33, 54, 12, 64,\n 57, 12, 52, 8, 58, 45, 42, 43, 54, 54, 59, 32, 35, 36, 20, 43, 40, 37,\n 45, 38, 41, 50, 29, 15, 34, 73, 30, 37, 55, 47, 21, 33, 37, 39, 60, 14,\n 52, 67, 48, 12, 37, 40, 57, 59, 64, 47, 13, 31, 57, 59, 30, 30, 22, 39,\n 38, 13, 32, 46, 24, 47, 16, 44, 32, 49, 28, 61, 65, 24, 24, 19, 22, 42,\n 20, 51, 43, 25, 27, 54, 28, 55, 36, 27, 32, 27, 55, 51, 41, 46, 37, 53,\n 19, 68, 44, 65, 29, 22, 55, 14, 59, 76, 50, 37, 46, 49, 38, 20, 34, 58,\n 52, 62, 30, 48, 45, 37, 17, 51, 33, 41, 18, 34, 17, 22, 51, 48, 14, 69,\n 26, 47, 54, 31, 19, 49, 49, 53, 51, 50, 69, 53, 27, 24, 33, 48, 50, 37,\n 42, 48, 37, 49, 68, 34, 49, 22, 44, 26, 39, 32, 43, 32, 55, 46, 73, 42,\n 18, 57, 53, 27, 3, 46, 51, 49, 59, 57, 26, 34, 32, 22, 47, 60, 35, 42,\n 28, 71, 30, 35, 52, 54, 54, 35, 35, 34, 37, 42, 70, 42, 33, 35, 56, 24,\n 34, 52, 54, 53, 41, 45, 24, 16, 35, 65, 38, 35, 45, 18, 46, 16, 19, 25,\n 34, 30, 49, 54, 28, 32, 46, 42, 30, 32, 31, 38, 28, 43, 34, 51, 52, 58,\n 45, 31, 59, 24, 31, 52, 33, 53, 26, 48, 45, 61, 38, 57, 36, 28, 37, 41,\n 40, 47, 25, 54, 17, 50, 30, 56, 26, 42, 34, 23, 19, 70, 45, 47, 68, 39,\n 24, 35, 56, 39, 26, 25, 22, 49, 40, 38, 32, 31, 32, 56, 48, 45, 43, 40,\n 58, 44, 37, 54, 40, 19, 27, 12, 41, 34, 29, 17, 86, 50, 49, 38, 22, 72,\n 33, 19, 47, 47, 59, 64, 62, 65, 62, 29, 49, 43, 46, 30, 70, 59, 40, 34,\n 52, 47, 29, 42, 31, 28, 68, 52, 24, 32, 40, 18, 35, 28, 41, 31, 58, 29,\n 58, 36, 31, 32, 34, 48, 66, 32, 34, 48, 35, 31, 22, 38, 23, 21, 42, 41,\n 34, 24, 65, 55, 29, 47, 43, 56, 38, 18, 31, 32, 54, 18, 22, 43, 67, 55,\n 24, 39, 49, 35, 46, 28, 28, 49, 18, 52, 28, 74, 62, 60, 59, 23, 36, 28,\n 61, 58, 68, 16, 25, 41, 38, 21, 51, 28, 56, 43, 38, 24, 29, 65, 37, 44,\n 25, 41, 40, 36, 36, 38, 57, 63, 29, 41, 51, 16, 71, 59, 14, 19, 36, 20,\n 31, 59, 75, 24, 36, 52, 53, 29, 50, 51, 68, 24, 49, 49, 18, 63, 57, 46,\n 46, 34, 63, 38, 40, 39, 46, 45, 49, 3, 73, 23, 30, 43, 63, 45, 46, 33,\n 20, 65, 35, 65, 65, 44, 19, 38, 14, 41, 53, 54, 61, 55, 40, 28, 53, 38,\n 38, 49, 65, 61, 50, 31, 42, 48, 13, 26, 64, 71, 46, 29, 25, 28, 60, 62,\n 48, 37, 73, 43, 21, 32, 57, 48, 20, 43, 52, 45, 47, 67, 21, 29, 32, 16,\n 56, 32, 71, 35, 29, 38, 52, 37, 57, 52, 19, 39, 65, 26, 33, 36, 25, 47,\n 40, 44, 36, 55, 28, 25, 25, 27, 44, 42, 36, 64, 24, 30, 41, 24, 30, 54,\n 38, 35, 43, 27, 57, 51, 34, 20, 15, 45, 34, 34, 49, 14, 28, 61, 50, 53,\n 69, 33, 9, 29, 55, 54, 45, 27, 51, 29, 68, 52, 52, 59, 18, 28, 21, 35,\n 52, 13, 19, 34, 40, 41, 33, 43, 38, 54, 66, 77, 11, 31, 51, 59, 34, 25,\n 66, 44, 25, 41, 21, 52, 36, 40, 26, 32, 31, 42, 52, 41, 27, 41, 25, 27,\n 45, 38, 48, 45, 27, 44, 31, 19, 38, 21, 57, 38, 65, 36, 57, 37, 38, 73,\n 48, 51, 52, 54, 37, 55, 52, 20, 37, 38, 48, 16, 45, 20, 36, 43, 51, 12,\n 27, 60, 46, 63, 48, 67, 31, 42, 37, 64, 21, 30, 49, 47, 41, 29, 45, 52,\n 35, 32, 61, 13, 36, 44, 35, 34, 40, 26, 38, 46, 48, 60, 52, 19, 29, 35,\n 37, 22, 61, 23, 43, 28, 27, 63, 30, 34, 52, 35, 56, 50, 37, 31, 16, 51,\n 39, 53, 52, 16, 24, 57, 23, 29, 26, 39, 40, 51, 53, 38, 54, 47, 35, 44,\n 44, 51, 29, 43, 55, 61, 39, 33, 43, 42, 51, 11, 47, 29, 67, 25, 47, 10,\n 66, 61, 29, 61, 20, 18, 51, 50, 36, 22, 42, 44, 43, 55, 21, 23, 28, 68,\n 24, 31, 70, 73, 70, 43, 16, 49, 32, 19, 56, 73, 28, 32, 39, 15, 46, 18,\n 42, 20, 43, 15, 65, 66, 21, 59, 27, 44, 31, 31, 38, 72, 44, 32, 46, 41,\n 40, 58, 33, 53, 63, 22, 16, 38, 40, 24, 61, 19, 29, 11, 18, 23, 49, 22,\n 20, 60, 35, 53, 28, 59, 49, 56, 27, 35, 61, 47, 61, 50, 44, 40, 22, 29,\n 59, 61, 59, 21, 52, 32, 44, 36, 23, 55, 42, 12, 55, 33, 46, 49, 10, 56,\n 25, 29, 42, 53, 55, 50, 27, 18, 22, 50, 47, 41, 54, 20, 56, 62, 18, 40,\n 26, 6, 62, 41, 51, 33, 36, 53, 52, 60, 17, 48, 36, 30, 27, 41, 27, 57,\n 14, 41, 53, 36, 44, 52, 27, 20, 44, 71, 38, 18, 35, 39, 34, 42, 17, 58,\n 47, 22, 28, 48, 19, 37, 38, 39, 12, 29, 61, 19, 30, 18, 31, 41, 53, 35,\n 32, 52, 20, 55, 35, 41, 45, 45, 35, 35, 50, 37, 29, 28, 53, 26, 55, 51,\n 31, 44, 25, 29, 21, 45, 42, 35, 17, 51, 34, 47, 70, 51, 48, 11, 44, 15,\n 64, 40, 51, 25, 47, 48, 53, 49, 47, 47, 42, 52, 50, 42, 52, 39, 48, 35,\n 51, 53, 34, 49, 59, 47, 45, 58, 27, 26, 22, 37, 42, 66, 46, 29, 52, 54,\n 34, 52, 39, 33, 52, 43, 41, 35, 46, 37, 47, 28, 40, 11, 37, 51, 55, 28,\n 71, 54, 48, 18, 45, 52, 41, 25, 19, 24, 54, 45, 36, 31, 31, 10, 45, 36,\n 41, 44, 41, 30, 65, 57, 65, 68, 24, 34, 50, 40, 56, 36, 26, 33, 71, 45,\n 5, 21, 50, 52, 31, 22, 30, 35, 56, 18, 28, 15, 37, 28, 37, 60, 36, 25,\n 26, 55, 54, 44, 55, 49, 49, 16, 42, 19, 39, 42, 46, 46, 41, 30, 28, 42,\n 69, 52, 32, 61, 45, 38, 9, 24, 28, 13, 26, 54, 49, 37, 47, 38, 49, 22,\n 55, 53, 48, 19, 46, 33, 27, 61, 31, 47, 46, 25, 25, 54, 18, 52, 38, 36,\n 27, 11, 42, 44, 48, 71, 42, 22, 53, 67, 26, 32, 49, 40, 32, 16, 36, 52,\n 27, 39, 44, 62, 85, 51, 41, 55, 64, 50, 39, 27, 38, 40, 35, 61, 24, 14,\n 55, 48, 49, 50, 44, 14, 17, 42, 59, 30, 38, 23, 55, 29, 34, 34, 44, 55,\n 28, 9, 27, 49, 49, 12, 51, 38, 44, 46, 55, 26, 42, 38, 18, 53, 70, 28,\n 70, 58, 41, 42, 44, 31, 46, 43, 22, 59, 22, 17, 18, 24, 32, 31, 51, 26,\n 14, 65, 47, 47, 55, 55, 29, 27, 55, 36, 38, 52, 36, 31, 44, 29, 29, 36,\n 39, 34, 22, 32, 44, 45, 22, 37, 16, 65, 46, 41, 18, 52, 48, 36, 36, 8,\n 60, 64, 29, 61, 35, 41, 46, 29, 34, 71, 26, 49, 42, 46, 60, 56, 35, 11,\n 58, 27, 42, 55, 47, 39, 28, 36, 34, 59, 38, 50, 58, 34, 59, 31, 41, 39,\n 14, 42, 27, 33, 34, 45, 56, 63, 46, 40, 21, 45, 34, 33, 44, 49, 35, 25,\n 35, 19, 62, 42, 34, 49, 63, 43, 48, 59, 55, 37, 26, 16, 82, 61, 41, 19,\n 11, 32, 50, 47, 55, 27, 26, 21, 28, 40, 69, 42, 45, 74, 40, 19, 38, 21,\n 62, 39, 31, 59, 29, 59, 27, 27, 56, 37, 35, 28, 26, 59, 39, 74, 59, 31,\n 56, 67, 48, 31, 28, 72, 27, 29, 36, 26, 44, 32, 39, 39, 74, 61, 34, 47,\n 47, 55, 21, 32, 18, 55, 24, 33, 46, 37, 56, 29, 39, 55, 41, 34, 36, 31,\n 48, 31, 49, 31, 63, 10, 87, 42, 38, 28, 32, 46, 29, 34, 52, 59, 21, 17,\n 31, 30, 57, 37, 37, 26, 46, 29, 58, 63, 18, 66, 37, 55, 53, 43, 53, 21,\n 47, 31, 41, 38, 26, 49, 36, 53, 37, 45, 63, 48, 13, 48, 39, 26, 35, 45,\n 43, 27, 49, 39, 29, 16, 49, 26, 26, 44, 45, 21, 39, 41, 52, 15, 25, 53,\n 36, 58, 45, 50, 32, 47, 40, 47, 38, 54, 55, 58, 48, 43, 50, 60, 43, 48,\n 20, 13, 32, 44, 57, 39, 12, 44, 59, 58, 33, 43, 59, 65, 58, 41, 25, 51,\n 33, 54, 32, 32, 34, 41, 65, 41, 48, 34, 38, 14, 54, 40, 46, 73, 18, 33,\n 37, 30, 42, 39, 29, 71, 29, 21, 38, 17, 45, 49, 25, 52, 35, 34, 42, 14,\n 40, 19, 40, 35, 45, 28, 36, 32, 64, 43, 50, 33, 27, 60, 42, 36, 36, 49,\n 69, 61, 41, 60, 27, 55, 25, 42, 43, 22, 39, 57, 48, 35, 53, 52, 47, 41,\n 27, 58, 43, 59, 27, 48, 20, 31, 52, 26, 50, 23, 75, 49, 37, 45, 57, 56,\n 44, 39, 34, 45, 30, 18, 35, 30, 76, 28, 51, 40, 55, 61, 67, 53, 24, 42,\n 42, 36, 51, 53, 71, 39, 31, 30, 42, 35, 24, 41, 65, 51, 16, 43, 47, 41,\n 50, 41, 24, 60, 24, 32, 48, 24, 64, 31, 60, 43, 18, 44, 41, 17, 38, 12,\n 34, 42, 38, 48, 7, 13, 62, 63, 13, 41, 51, 31, 34, 29, 35, 48, 38, 15,\n 53, 32, 70, 40, 8, 31, 22, 27, 26, 54, 16, 43, 15, 22, 42, 48, 53, 64,\n 63, 20, 37, 40, 36, 4, 42, 42, 43, 32, 54, 66, 72, 30, 38, 30, 35, 41,\n 47, 21, 18, 63, 33, 31, 39, 59, 42, 20, 47, 27, 47, 59, 22, 34, 45, 14,\n 63, 40, 54, 25, 19, 44, 46, 60, 55, 47, 48, 16, 34, 37, 49, 22, 34, 17,\n 17, 59, 25, 44, 39, 47, 31, 40, 38, 50, 50, 50, 46, 45, 38, 39, 23, 12,\n 21, 47, 15, 37, 38, 20, 27, 58, 37, 70, 28, 18, 41, 12, 29, 30, 47, 27,\n 50, 29, 39, 17, 31, 17, 41, 29, 50, 42, 65, 32, 13, 17, 34, 54, 32, 48,\n 39, 67, 56, 15, 41, 36, 39, 28, 30, 45, 45, 34, 46, 30, 40, 56, 48, 26,\n 43, 22, 61, 31, 28, 29, 50, 16, 65, 54, 44, 52, 28, 32, 19, 42, 42, 39,\n 39, 59, 28, 60, 66, 23, 31, 24, 28, 13, 60, 38, 27, 35, 48, 59, 40, 62,\n 46, 70, 25, 54, 50, 32, 46, 57, 40, 38, 11, 45, 53, 21, 50, 30, 40, 43,\n 16, 32, 51, 42, 49, 60, 60, 37, 44, 73, 45, 55, 33, 42, 31, 49, 44, 21,\n 62, 50, 58, 26, 17, 71, 17, 27, 39, 50, 40, 43, 44, 31, 21, 44, 43, 22,\n 60, 29, 57, 20, 39, 44, 33, 34, 34, 41, 16, 25, 51, 23, 48, 17, 34, 24,\n 40, 27, 39, 28, 24, 26, 36, 37, 23, 57, 29, 56, 23, 41, 67, 35, 23, 10,\n 69, 56, 53, 50, 45, 32, 52, 39, 42, 30, 36, 47, 47, 36, 21, 21, 51, 24,\n 72, 10, 17, 52, 39, 39, 19, 20, 36, 54, 36, 34, 49, 63, 37, 24, 21, 43,\n 28, 65, 32, 29, 38, 23, 31, 9, 44, 51, 26, 52, 54, 28, 52, 46, 32, 50,\n 43, 46, 40, 24, 42, 38, 24, 46, 44, 40, 29, 35, 27, 55, 32, 28, 23, 13,\n 33, 31, 37, 18, 19, 37, 42, 18, 24, 36, 25, 54, 65, 6, 43, 27, 37, 68,\n 42, 33, 41, 48, 45, 66, 15, 27, 34]},\n 'test_4': {'capacity': 100, 'num_items': 5000,\n 'items': [38, 34, 46, 40, 59, 55, 27, 37, 11, 63, 9, 31, 18, 52, 43, 50, 47, 34,\n 44, 47, 50, 41, 17, 40, 52, 55, 27, 29, 28, 54, 13, 57, 40, 15, 35, 27,\n 13, 28, 20, 8, 24, 47, 38, 48, 26, 34, 36, 47, 39, 10, 19, 57, 39, 44,\n 43, 56, 31, 48, 50, 26, 52, 52, 56, 41, 49, 37, 46, 37, 29, 47, 43, 30,\n 32, 24, 47, 37, 55, 47, 43, 10, 50, 27, 50, 27, 33, 51, 15, 43, 45, 48,\n 44, 59, 32, 44, 40, 46, 66, 39, 51, 30, 38, 25, 38, 28, 48, 50, 14, 41,\n 39, 31, 33, 38, 17, 24, 32, 23, 18, 55, 41, 40, 66, 35, 51, 63, 50, 88,\n 31, 63, 34, 51, 58, 32, 43, 59, 65, 43, 40, 31, 47, 66, 47, 45, 61, 24,\n 43, 53, 37, 36, 57, 19, 51, 6, 29, 41, 30, 11, 25, 50, 53, 53, 52, 42,\n 22, 29, 39, 25, 25, 34, 52, 50, 42, 59, 42, 50, 52, 49, 22, 60, 37, 50,\n 45, 24, 30, 40, 64, 33, 64, 47, 26, 55, 29, 39, 60, 27, 34, 41, 43, 35,\n 49, 40, 39, 51, 33, 45, 48, 64, 19, 47, 23, 41, 53, 35, 43, 33, 39, 34,\n 63, 27, 42, 34, 54, 52, 74, 27, 59, 71, 56, 33, 41, 16, 74, 34, 38, 41,\n 29, 30, 28, 28, 51, 29, 53, 27, 6, 15, 35, 63, 16, 52, 43, 21, 41, 21,\n 36, 32, 52, 39, 32, 25, 37, 52, 58, 21, 32, 35, 61, 52, 23, 58, 36, 19,\n 51, 61, 42, 40, 30, 34, 25, 28, 28, 19, 20, 30, 34, 63, 30, 53, 49, 24,\n 20, 54, 45, 18, 52, 49, 43, 37, 33, 44, 42, 43, 50, 33, 25, 29, 64, 43,\n 63, 45, 58, 59, 50, 73, 48, 34, 8, 26, 50, 21, 80, 24, 36, 26, 37, 65,\n 53, 50, 50, 60, 33, 81, 43, 57, 25, 67, 35, 35, 47, 52, 14, 60, 36, 27,\n 52, 24, 37, 44, 57, 42, 33, 37, 39, 43, 58, 44, 35, 46, 50, 47, 74, 25,\n 46, 27, 53, 54, 37, 46, 39, 27, 32, 49, 77, 37, 68, 34, 63, 56, 44, 45,\n 26, 74, 47, 52, 37, 37, 67, 26, 28, 39, 49, 25, 34, 40, 30, 56, 47, 50,\n 56, 32, 26, 50, 51, 40, 27, 61, 54, 42, 25, 43, 17, 41, 49, 26, 51, 22,\n 15, 52, 50, 31, 28, 31, 55, 32, 20, 33, 54, 49, 32, 42, 68, 47, 64, 6,\n 37, 38, 44, 37, 25, 9, 60, 44, 38, 40, 62, 48, 49, 55, 40, 55, 41, 40,\n 42, 51, 46, 61, 54, 45, 34, 48, 80, 63, 28, 31, 41, 49, 30, 41, 13, 48,\n 65, 59, 33, 42, 24, 48, 48, 30, 75, 43, 62, 60, 65, 15, 19, 33, 47, 36,\n 21, 31, 41, 23, 38, 51, 42, 58, 14, 42, 12, 20, 37, 35, 42, 43, 15, 43,\n 28, 42, 34, 55, 35, 43, 49, 28, 16, 40, 26, 27, 41, 35, 27, 46, 38, 31,\n 36, 21, 35, 64, 35, 33, 42, 13, 49, 51, 59, 53, 18, 27, 67, 20, 38, 26,\n 37, 33, 44, 31, 21, 23, 46, 38, 36, 65, 39, 52, 35, 42, 30, 38, 33, 45,\n 72, 21, 35, 54, 29, 57, 52, 33, 20, 30, 45, 33, 53, 73, 48, 49, 32, 36,\n 62, 66, 30, 56, 53, 29, 42, 24, 46, 39, 20, 43, 38, 52, 25, 58, 22, 38,\n 44, 48, 34, 40, 32, 8, 35, 45, 25, 68, 30, 45, 67, 56, 40, 22, 30, 74,\n 27, 48, 33, 67, 39, 11, 37, 53, 45, 57, 42, 45, 50, 47, 40, 40, 61, 64,\n 51, 28, 18, 12, 49, 43, 47, 44, 55, 31, 53, 37, 31, 47, 48, 31, 39, 42,\n 50, 14, 33, 42, 39, 50, 37, 55, 47, 50, 78, 37, 38, 30, 61, 39, 48, 30,\n 26, 48, 62, 46, 27, 54, 38, 36, 46, 34, 35, 64, 24, 39, 75, 29, 70, 38,\n 28, 39, 10, 24, 49, 47, 33, 47, 58, 30, 10, 26, 28, 43, 33, 29, 46, 36,\n 35, 19, 36, 10, 37, 31, 7, 42, 46, 63, 82, 49, 42, 42, 22, 54, 42, 50,\n 30, 51, 61, 48, 43, 29, 13, 33, 36, 58, 38, 47, 59, 57, 19, 33, 56, 7,\n 49, 41, 49, 11, 40, 68, 28, 11, 36, 39, 26, 26, 64, 25, 36, 18, 53, 33,\n 39, 45, 62, 30, 23, 38, 31, 26, 35, 26, 4, 44, 39, 34, 29, 23, 36, 62,\n 39, 41, 38, 14, 55, 19, 46, 57, 51, 37, 19, 27, 33, 36, 34, 38, 43, 27,\n 66, 30, 27, 46, 48, 48, 59, 81, 58, 40, 50, 35, 45, 51, 53, 53, 46, 52,\n 39, 17, 49, 35, 32, 41, 54, 46, 33, 42, 44, 24, 43, 45, 28, 29, 44, 44,\n 34, 46, 44, 17, 54, 27, 39, 42, 41, 26, 39, 57, 38, 17, 21, 52, 47, 24,\n 32, 37, 45, 13, 62, 48, 31, 42, 19, 23, 30, 50, 15, 31, 28, 42, 51, 45,\n 47, 23, 40, 52, 85, 54, 36, 20, 38, 34, 18, 25, 14, 34, 43, 21, 35, 39,\n 45, 33, 52, 24, 40, 51, 29, 26, 51, 41, 64, 57, 29, 45, 48, 35, 37, 38,\n 42, 46, 36, 43, 26, 41, 62, 62, 63, 6, 21, 30, 30, 21, 36, 33, 58, 41,\n 53, 29, 42, 9, 57, 27, 37, 48, 25, 23, 31, 33, 32, 42, 35, 15, 13, 61,\n 30, 16, 47, 25, 31, 62, 5, 50, 19, 38, 61, 27, 26, 35, 40, 24, 31, 30,\n 18, 18, 41, 36, 61, 11, 46, 7, 8, 42, 39, 28, 28, 33, 37, 37, 44, 6, 53,\n 35, 29, 35, 67, 29, 31, 49, 34, 46, 21, 23, 35, 48, 28, 38, 67, 45, 59,\n 44, 50, 61, 24, 49, 58, 9, 16, 40, 14, 18, 34, 47, 37, 56, 22, 41, 39,\n 35, 59, 57, 34, 24, 16, 48, 36, 38, 44, 23, 79, 24, 10, 36, 51, 32, 39,\n 43, 55, 28, 27, 25, 42, 45, 63, 24, 41, 47, 19, 32, 26, 57, 30, 24, 32,\n 62, 73, 35, 65, 30, 67, 38, 41, 30, 37, 48, 22, 58, 50, 8, 42, 44, 72,\n 42, 67, 24, 64, 55, 54, 42, 13, 13, 27, 27, 19, 53, 28, 33, 23, 36, 70,\n 54, 55, 37, 56, 35, 35, 53, 3, 43, 26, 43, 29, 69, 45, 61, 45, 46, 19,\n 40, 25, 43, 38, 62, 45, 58, 71, 45, 28, 42, 42, 11, 56, 58, 39, 35, 66,\n 23, 30, 42, 35, 50, 24, 44, 61, 56, 42, 41, 56, 48, 54, 21, 35, 51, 21,\n 29, 16, 44, 40, 50, 34, 38, 63, 58, 20, 51, 30, 39, 33, 29, 7, 39, 36,\n 59, 16, 45, 54, 49, 73, 30, 55, 32, 53, 83, 28, 44, 38, 54, 32, 23, 30,\n 50, 12, 52, 52, 46, 28, 47, 32, 26, 8, 60, 9, 36, 27, 27, 69, 49, 45, 31,\n 16, 48, 14, 31, 36, 44, 35, 48, 47, 51, 55, 40, 43, 42, 21, 51, 70, 53,\n 18, 37, 37, 53, 26, 28, 53, 65, 33, 27, 17, 42, 32, 19, 65, 31, 13, 32,\n 42, 24, 45, 54, 51, 48, 45, 54, 60, 31, 62, 43, 43, 43, 58, 33, 9, 46,\n 43, 16, 77, 52, 55, 46, 70, 78, 35, 42, 27, 24, 62, 40, 41, 43, 60, 43,\n 46, 27, 54, 47, 49, 51, 35, 42, 46, 21, 37, 47, 13, 39, 42, 21, 24, 45,\n 11, 50, 29, 36, 43, 49, 46, 28, 36, 47, 49, 42, 35, 57, 44, 41, 51, 59,\n 68, 37, 40, 32, 67, 21, 35, 28, 36, 35, 60, 39, 35, 39, 13, 51, 24, 8,\n 21, 59, 34, 42, 33, 41, 44, 22, 35, 33, 45, 80, 36, 42, 26, 25, 45, 46,\n 23, 30, 27, 53, 58, 50, 71, 39, 35, 49, 18, 56, 43, 16, 51, 24, 60, 53,\n 57, 51, 27, 34, 49, 47, 55, 37, 13, 11, 34, 53, 21, 24, 29, 61, 56, 45,\n 15, 33, 40, 31, 18, 36, 44, 9, 20, 41, 48, 34, 38, 35, 65, 48, 18, 11,\n 37, 28, 39, 51, 59, 42, 54, 44, 41, 10, 30, 54, 44, 38, 22, 44, 11, 54,\n 30, 40, 50, 49, 34, 26, 33, 39, 31, 44, 51, 47, 40, 41, 9, 42, 28, 45,\n 28, 36, 47, 50, 7, 47, 64, 43, 44, 46, 46, 11, 45, 26, 29, 31, 61, 44,\n 53, 71, 31, 69, 6, 42, 38, 51, 34, 51, 38, 45, 27, 29, 32, 25, 32, 25,\n 36, 43, 56, 49, 36, 36, 60, 46, 24, 36, 45, 57, 56, 41, 43, 35, 18, 52,\n 33, 41, 66, 71, 25, 28, 17, 11, 40, 34, 34, 12, 38, 31, 24, 52, 39, 19,\n 66, 55, 24, 43, 24, 33, 39, 66, 30, 24, 8, 62, 55, 64, 40, 59, 53, 42,\n 52, 29, 26, 24, 40, 32, 43, 30, 38, 55, 39, 16, 27, 33, 58, 31, 66, 35,\n 30, 26, 18, 34, 50, 35, 23, 30, 36, 36, 21, 33, 46, 52, 48, 31, 30, 29,\n 9, 27, 26, 40, 39, 45, 38, 60, 40, 34, 49, 45, 78, 34, 29, 56, 38, 20,\n 83, 19, 34, 37, 33, 54, 69, 47, 32, 49, 45, 48, 42, 19, 44, 30, 21, 39,\n 30, 29, 67, 37, 29, 33, 74, 38, 36, 10, 26, 27, 26, 49, 57, 56, 26, 34,\n 33, 9, 20, 22, 36, 53, 16, 69, 28, 35, 58, 53, 9, 50, 43, 30, 58, 49, 39,\n 40, 27, 42, 40, 42, 19, 39, 46, 58, 62, 30, 48, 30, 39, 36, 17, 37, 51,\n 18, 56, 48, 18, 24, 39, 21, 48, 8, 45, 36, 42, 44, 38, 50, 40, 51, 27,\n 23, 47, 16, 62, 49, 37, 44, 50, 17, 45, 45, 68, 12, 22, 59, 54, 38, 11,\n 43, 51, 21, 34, 29, 49, 41, 17, 33, 78, 18, 30, 47, 71, 33, 56, 44, 55,\n 46, 48, 50, 45, 31, 45, 27, 50, 46, 36, 43, 40, 59, 52, 53, 44, 29, 33,\n 59, 29, 55, 48, 38, 38, 21, 52, 22, 35, 38, 19, 31, 51, 47, 52, 41, 29,\n 26, 28, 60, 27, 40, 61, 44, 39, 36, 34, 37, 37, 39, 48, 73, 26, 24, 34,\n 29, 32, 59, 40, 41, 31, 14, 63, 19, 38, 45, 40, 58, 27, 55, 66, 45, 31,\n 28, 51, 22, 31, 15, 16, 31, 29, 34, 55, 52, 33, 46, 43, 70, 44, 40, 33,\n 31, 28, 52, 22, 37, 61, 17, 15, 21, 42, 54, 35, 25, 63, 15, 38, 52, 49,\n 58, 39, 65, 32, 31, 52, 43, 46, 44, 51, 34, 43, 56, 60, 80, 10, 46, 18,\n 17, 25, 37, 33, 34, 61, 31, 44, 64, 22, 30, 22, 35, 57, 38, 37, 42, 56,\n 39, 54, 25, 57, 52, 58, 36, 27, 36, 43, 24, 50, 60, 36, 16, 26, 18, 62,\n 50, 19, 39, 15, 34, 27, 49, 33, 22, 49, 45, 33, 43, 39, 65, 20, 44, 58,\n 42, 24, 38, 36, 23, 37, 41, 35, 33, 10, 31, 58, 59, 24, 36, 39, 61, 27,\n 43, 34, 37, 37, 31, 55, 44, 28, 11, 48, 34, 56, 41, 67, 51, 35, 26, 40,\n 22, 31, 46, 36, 21, 29, 22, 37, 31, 30, 68, 37, 47, 37, 33, 31, 72, 48,\n 33, 40, 44, 47, 52, 20, 25, 61, 27, 33, 57, 61, 46, 17, 29, 15, 68, 31,\n 35, 24, 54, 42, 24, 9, 12, 48, 52, 43, 43, 42, 23, 57, 53, 75, 36, 59,\n 46, 40, 38, 37, 51, 52, 30, 62, 41, 41, 71, 57, 20, 40, 51, 26, 60, 46,\n 57, 12, 9, 47, 26, 30, 30, 51, 27, 20, 47, 64, 36, 32, 34, 68, 31, 34,\n 18, 42, 24, 25, 17, 20, 78, 61, 47, 61, 19, 42, 27, 28, 52, 35, 14, 37,\n 51, 44, 44, 57, 48, 49, 46, 23, 41, 39, 37, 45, 70, 38, 30, 16, 36, 45,\n 26, 53, 29, 39, 29, 59, 28, 42, 31, 60, 52, 18, 34, 38, 52, 32, 40, 60,\n 81, 58, 55, 19, 28, 62, 54, 52, 35, 13, 9, 26, 26, 70, 49, 25, 30, 33,\n 12, 54, 29, 32, 51, 30, 64, 54, 28, 39, 23, 31, 22, 38, 40, 54, 42, 75,\n 34, 15, 33, 63, 37, 32, 21, 34, 47, 47, 39, 39, 49, 33, 31, 49, 43, 45,\n 55, 62, 39, 17, 53, 47, 39, 42, 22, 47, 64, 29, 17, 34, 24, 34, 47, 4,\n 32, 54, 63, 52, 32, 31, 43, 38, 36, 34, 21, 46, 60, 35, 25, 40, 18, 36,\n 50, 34, 27, 73, 48, 31, 48, 37, 19, 24, 61, 20, 36, 60, 32, 25, 39, 40,\n 38, 52, 21, 7, 52, 79, 60, 58, 57, 50, 50, 27, 40, 45, 21, 36, 28, 23,\n 38, 41, 35, 42, 6, 26, 23, 36, 19, 59, 41, 28, 45, 45, 57, 33, 55, 63,\n 42, 19, 35, 47, 17, 44, 31, 11, 7, 15, 36, 66, 42, 19, 41, 40, 30, 49,\n 49, 55, 51, 48, 21, 51, 39, 32, 42, 38, 61, 44, 26, 12, 25, 28, 52, 14,\n 56, 23, 47, 36, 51, 25, 31, 43, 34, 58, 25, 30, 34, 24, 90, 49, 36, 20,\n 55, 49, 43, 22, 64, 76, 33, 57, 50, 28, 42, 40, 23, 56, 39, 27, 23, 40,\n 47, 38, 49, 52, 39, 39, 43, 17, 44, 28, 43, 49, 53, 70, 31, 48, 63, 29,\n 25, 31, 45, 29, 40, 43, 46, 17, 27, 60, 56, 53, 54, 66, 30, 44, 29, 46,\n 32, 22, 40, 28, 34, 37, 19, 51, 42, 26, 19, 28, 66, 36, 33, 62, 23, 70,\n 62, 54, 49, 44, 39, 59, 58, 60, 39, 75, 41, 59, 33, 63, 51, 53, 38, 28,\n 52, 80, 39, 50, 29, 63, 48, 54, 32, 19, 11, 55, 27, 39, 36, 33, 18, 39,\n 15, 38, 23, 35, 46, 34, 31, 25, 26, 55, 30, 32, 22, 56, 45, 39, 31, 21,\n 28, 68, 36, 35, 45, 17, 36, 47, 23, 37, 17, 42, 53, 37, 42, 53, 45, 23,\n 34, 30, 26, 42, 39, 31, 43, 62, 55, 40, 75, 37, 41, 40, 26, 35, 26, 65,\n 18, 41, 37, 31, 43, 60, 62, 44, 42, 74, 41, 51, 30, 40, 49, 52, 55, 36,\n 22, 41, 50, 19, 53, 11, 32, 24, 18, 34, 62, 47, 39, 35, 34, 32, 35, 23,\n 36, 28, 37, 48, 65, 46, 57, 7, 26, 69, 38, 58, 50, 47, 38, 21, 50, 35,\n 45, 40, 46, 36, 48, 58, 36, 30, 54, 38, 56, 24, 44, 35, 30, 33, 27, 81,\n 44, 80, 45, 49, 38, 19, 23, 30, 27, 40, 71, 35, 67, 18, 33, 73, 46, 33,\n 44, 51, 31, 52, 44, 57, 51, 26, 27, 67, 23, 14, 36, 34, 41, 40, 55, 23,\n 37, 18, 21, 26, 43, 33, 42, 53, 21, 35, 52, 51, 30, 48, 30, 37, 50, 46,\n 8, 43, 30, 54, 53, 35, 58, 38, 47, 35, 8, 52, 38, 37, 81, 29, 43, 55, 37,\n 25, 49, 41, 39, 32, 38, 46, 59, 18, 46, 46, 44, 14, 35, 50, 49, 16, 33,\n 44, 36, 42, 77, 33, 36, 51, 39, 18, 58, 10, 43, 58, 60, 55, 41, 25, 63,\n 20, 39, 69, 29, 30, 65, 59, 23, 50, 25, 33, 36, 31, 44, 23, 54, 8, 49,\n 14, 31, 39, 61, 58, 32, 59, 37, 32, 57, 26, 38, 64, 61, 45, 37, 39, 45,\n 36, 28, 41, 38, 28, 20, 37, 57, 30, 36, 53, 42, 58, 26, 45, 18, 74, 53,\n 48, 52, 23, 49, 20, 35, 8, 27, 38, 65, 28, 7, 48, 29, 48, 50, 37, 41, 56,\n 36, 43, 44, 30, 32, 21, 48, 40, 29, 52, 56, 37, 57, 34, 16, 54, 20, 56,\n 33, 16, 38, 25, 74, 20, 52, 25, 60, 50, 29, 44, 60, 35, 32, 41, 42, 26,\n 43, 25, 30, 36, 31, 23, 48, 14, 29, 32, 59, 41, 32, 27, 23, 34, 41, 30,\n 46, 66, 52, 66, 31, 39, 25, 78, 24, 47, 33, 54, 7, 34, 56, 28, 33, 31,\n 40, 31, 15, 62, 42, 47, 44, 43, 25, 35, 32, 45, 6, 45, 20, 65, 13, 29,\n 47, 49, 43, 37, 51, 38, 50, 52, 48, 40, 55, 49, 23, 42, 38, 18, 21, 45,\n 56, 37, 33, 28, 50, 46, 43, 34, 67, 27, 22, 33, 44, 37, 27, 50, 46, 37,\n 14, 49, 24, 53, 34, 26, 54, 27, 35, 46, 45, 78, 18, 41, 25, 29, 30, 17,\n 17, 7, 50, 21, 69, 49, 61, 15, 35, 33, 7, 27, 20, 32, 45, 40, 54, 18, 15,\n 54, 42, 50, 41, 69, 45, 48, 49, 59, 27, 26, 63, 66, 35, 32, 50, 18, 31,\n 51, 62, 57, 59, 19, 47, 51, 32, 44, 65, 26, 43, 60, 65, 33, 50, 22, 32,\n 34, 45, 59, 90, 68, 52, 38, 37, 25, 46, 49, 29, 15, 46, 26, 36, 37, 50,\n 35, 29, 23, 31, 19, 68, 37, 34, 33, 49, 65, 43, 41, 52, 35, 37, 30, 30,\n 37, 30, 41, 58, 22, 36, 66, 43, 50, 49, 29, 39, 42, 70, 20, 30, 62, 41,\n 29, 29, 45, 38, 59, 46, 5, 31, 52, 44, 51, 60, 45, 33, 50, 40, 39, 46,\n 45, 63, 32, 53, 53, 43, 31, 34, 69, 36, 61, 18, 28, 26, 38, 31, 19, 55,\n 42, 53, 39, 62, 29, 55, 59, 22, 53, 29, 46, 39, 26, 26, 61, 38, 26, 50,\n 59, 53, 52, 42, 24, 25, 54, 15, 48, 43, 37, 31, 51, 26, 59, 37, 66, 68,\n 39, 39, 47, 28, 45, 42, 57, 41, 66, 21, 25, 58, 29, 40, 28, 27, 78, 39,\n 44, 27, 67, 63, 35, 63, 22, 49, 26, 44, 36, 34, 34, 38, 42, 44, 43, 41,\n 52, 7, 20, 51, 38, 50, 58, 35, 36, 27, 35, 48, 34, 67, 20, 48, 31, 40,\n 14, 65, 45, 75, 35, 32, 24, 46, 44, 30, 20, 50, 17, 38, 58, 60, 24, 53,\n 51, 56, 44, 65, 18, 52, 32, 35, 56, 37, 42, 48, 54, 48, 18, 22, 42, 32,\n 40, 39, 40, 41, 57, 53, 36, 26, 34, 26, 61, 42, 54, 50, 46, 56, 34, 43,\n 33, 41, 35, 20, 16, 32, 54, 50, 54, 60, 70, 24, 35, 47, 30, 13, 31, 46,\n 41, 36, 44, 48, 32, 33, 33, 56, 51, 39, 30, 46, 41, 54, 39, 48, 46, 43,\n 26, 34, 27, 43, 25, 57, 61, 62, 19, 47, 23, 27, 36, 48, 47, 58, 60, 23,\n 36, 31, 32, 10, 44, 46, 33, 49, 31, 67, 24, 40, 52, 15, 40, 44, 28, 48,\n 37, 40, 39, 45, 34, 50, 47, 29, 44, 20, 54, 35, 30, 51, 35, 44, 34, 54,\n 48, 35, 51, 28, 52, 36, 18, 40, 55, 19, 62, 58, 31, 22, 19, 32, 59, 42,\n 30, 32, 51, 67, 20, 38, 33, 94, 37, 59, 69, 61, 33, 35, 40, 43, 33, 28,\n 38, 48, 52, 43, 21, 55, 64, 38, 57, 47, 34, 39, 35, 40, 67, 34, 35, 64,\n 25, 21, 31, 41, 44, 24, 49, 54, 32, 23, 64, 64, 32, 37, 55, 45, 38, 45,\n 34, 35, 36, 35, 41, 29, 34, 55, 34, 45, 18, 48, 38, 24, 35, 45, 49, 34,\n 57, 34, 51, 57, 21, 47, 53, 64, 40, 54, 58, 14, 51, 63, 29, 56, 41, 64,\n 25, 21, 40, 75, 13, 50, 34, 45, 50, 65, 32, 42, 19, 41, 33, 18, 26, 35,\n 50, 40, 22, 34, 44, 55, 56, 10, 31, 13, 39, 20, 47, 12, 44, 52, 41, 43,\n 52, 31, 49, 35, 37, 58, 20, 17, 14, 38, 59, 27, 56, 21, 36, 54, 35, 26,\n 17, 26, 50, 32, 58, 37, 60, 57, 52, 42, 15, 54, 21, 18, 40, 48, 29, 38,\n 42, 48, 21, 46, 41, 48, 19, 20, 36, 21, 36, 49, 53, 16, 53, 22, 25, 62,\n 45, 23, 28, 30, 63, 44, 23, 37, 28, 22, 65, 43, 60, 21, 8, 25, 28, 52,\n 58, 46, 59, 4, 47, 64, 23, 35, 31, 33, 50, 45, 45, 24, 46, 51, 52, 68,\n 47, 19, 48, 63, 30, 38, 25, 41, 40, 59, 40, 23, 41, 27, 71, 30, 31, 73,\n 72, 52, 49, 30, 58, 53, 32, 72, 44, 45, 52, 43, 66, 43, 48, 17, 41, 27,\n 72, 24, 20, 63, 42, 36, 13, 41, 67, 40, 41, 34, 30, 39, 23, 38, 26, 46,\n 19, 26, 65, 46, 20, 31, 32, 49, 60, 58, 41, 9, 18, 29, 54, 34, 47, 51,\n 28, 44, 52, 44, 22, 56, 30, 52, 14, 41, 71, 50, 27, 15, 44, 25, 43, 39,\n 38, 58, 39, 51, 49, 27, 50, 52, 31, 17, 44, 45, 15, 42, 34, 51, 53, 55,\n 18, 66, 61, 22, 22, 36, 27, 64, 13, 76, 65, 36, 22, 30, 42, 57, 34, 52,\n 17, 58, 71, 39, 75, 24, 44, 18, 37, 64, 45, 23, 16, 22, 49, 46, 33, 46,\n 39, 41, 35, 30, 37, 25, 24, 47, 65, 20, 43, 55, 71, 27, 21, 55, 55, 48,\n 46, 8, 46, 46, 34, 19, 54, 58, 52, 42, 28, 13, 66, 33, 43, 21, 51, 55,\n 41, 43, 44, 48, 17, 22, 41, 39, 44, 53, 20, 32, 39, 64, 27, 50, 44, 43,\n 51, 34, 24, 26, 61, 42, 17, 45, 37, 60, 30, 22, 23, 44, 43, 33, 55, 29,\n 32, 31, 31, 51, 65, 80, 43, 57, 44, 29, 24, 12, 64, 42, 52, 24, 51, 22,\n 39, 42, 55, 33, 48, 47, 62, 31, 46, 14, 25, 55, 34, 21, 29, 47, 44, 21,\n 44, 58, 59, 24, 29, 38, 51, 39, 25, 44, 37, 62, 13, 48, 48, 39, 43, 12,\n 6, 52, 27, 47, 44, 34, 54, 42, 49, 38, 34, 35, 62, 35, 36, 49, 32, 19,\n 48, 61, 32, 57, 58, 27, 52, 44, 39, 26, 23, 42, 45, 56, 55, 52, 35, 38,\n 31, 31, 28, 20, 40, 48, 44, 40, 71, 63, 48, 44, 52, 47, 35, 63, 62, 25,\n 37, 35, 35, 39, 32, 43, 45, 58, 68, 25, 37, 50, 48, 30, 51, 31, 28, 52,\n 63, 50, 81, 36, 59, 48, 44, 27, 18, 19, 26, 54, 54, 39, 43, 24, 40, 13,\n 39, 22, 23, 29, 53, 34, 23, 61, 56, 43, 49, 48, 49, 42, 9, 27, 33, 39,\n 29, 26, 53, 46, 46, 43, 41, 28, 34, 29, 33, 43, 44, 15, 41, 30, 32, 55,\n 75, 50, 26, 55, 68, 15, 17, 22, 55, 33, 52, 23, 39, 39, 39, 74, 18, 21,\n 37, 36, 23, 64, 51, 20, 65, 38, 25, 68, 58, 33, 53, 27, 25, 59, 35, 49,\n 51, 28, 38, 40, 36, 27, 46, 24, 17, 47, 38, 64, 52, 18, 32, 20, 27, 48,\n 37, 46, 77, 10, 39, 33, 48, 29, 38, 37, 41, 81, 39, 19, 54, 46, 33, 60,\n 29, 52, 40, 14, 54, 38, 27, 34, 41, 37, 34, 57, 18, 23, 36, 31, 73, 39,\n 40, 33, 31, 22, 35, 36, 50, 28, 41, 31, 18, 38, 53, 27, 43, 33, 29, 34,\n 36, 48, 18, 39, 38, 27, 47, 51, 68, 44, 39, 16, 29, 54, 16, 42, 38, 43,\n 33, 25, 27, 56, 57, 57, 50, 59, 42, 46, 58, 48, 52, 37, 10, 25, 63, 18,\n 49, 26, 32, 23, 31, 47, 28, 11, 32, 54, 17, 66, 27, 31, 30, 50, 49, 36,\n 20, 32, 72, 30, 27, 14, 58, 40, 41, 51, 39, 48, 19, 49, 58, 58, 50, 54,\n 40, 29, 30, 33, 33, 44, 39, 39, 32, 37, 45, 38, 48, 28, 41, 40, 53, 52,\n 29, 38, 44, 57, 22, 39, 24, 45, 20, 38, 53, 43, 38, 54, 40, 35, 17, 53,\n 18, 34, 44, 18, 38, 55, 48, 46, 35, 26, 21, 34, 62, 53, 46, 30, 6, 18,\n 63, 56, 15, 58, 68, 47, 49, 47, 43, 26, 42, 31, 28, 42, 18, 35, 66, 45,\n 53, 67, 41, 31, 34, 48, 42, 57, 40, 47, 16, 67, 45, 61, 8, 12, 44, 74,\n 35, 41, 40, 37, 38, 46, 37, 56, 32, 57, 25, 51, 48, 47, 31, 60, 15, 64,\n 39, 46, 37, 38, 10, 48, 31, 62, 13, 26, 34, 33, 53, 61, 28, 67, 8, 33,\n 24, 32, 26, 66, 35, 52, 32, 43, 43, 27, 45, 34, 33, 35, 51, 33, 48, 39,\n 33, 40, 20, 30, 32, 34, 71, 62, 29, 54, 31, 24, 47, 11, 22, 18, 34, 41,\n 36, 65, 41, 35, 63, 27, 29, 44, 38, 13, 36, 23, 25, 40, 55, 47, 49, 46,\n 36, 53, 38, 16, 13, 28, 63, 28, 49, 15, 46, 12, 24, 50, 24, 49, 61, 79,\n 37, 21, 45, 33, 38, 38, 30, 49, 48, 52, 49, 45, 48, 9, 47, 49, 44, 49,\n 28, 28, 43, 10, 46, 52, 15, 51, 45, 54, 30, 10, 50, 25, 44, 25, 53, 50,\n 13, 65, 20, 66, 25, 39, 10, 40, 10, 38, 50, 36, 30, 51, 46, 53, 31, 41,\n 42, 35, 62, 51, 14, 33, 37, 57, 43, 56, 21, 22, 50, 41, 50, 27, 32, 11,\n 49, 56, 23, 54, 32, 46, 44, 29, 31, 25, 19, 50, 37, 46, 47, 48, 51, 20,\n 43, 57, 33, 44, 46, 70, 34, 45, 13, 36, 53, 28, 50, 10, 48, 27, 19, 52,\n 22, 51, 49, 65, 21, 40, 40, 18, 53, 27, 38, 37, 32, 74, 52, 23, 40, 54,\n 55, 51, 61, 34, 37, 43, 33, 33, 73, 48, 46, 48, 54, 49, 20, 33, 37, 43,\n 15, 36, 42, 40, 29, 43, 18, 31, 56, 36, 24, 57, 48, 67, 20, 16, 15, 62,\n 35, 53, 36, 43, 35, 35, 51, 62, 53, 66, 44, 34, 50, 34, 40, 58, 44, 52,\n 25, 30, 23, 52, 32, 50, 27, 28, 48, 30, 53, 50, 50, 35, 15, 22, 19, 45,\n 51, 22, 39, 36, 49, 61, 57, 58, 40, 43, 81, 79, 54, 41, 20, 22, 37, 12,\n 34, 61, 23, 37, 57, 36, 38, 43, 30, 60, 20, 45, 35, 32, 23, 27, 33, 30,\n 22, 24, 51, 23, 26, 35, 10, 70, 48, 38, 11, 24, 67, 32, 24, 62, 49, 24,\n 30, 49, 51, 31, 32, 14, 59, 50, 51, 30, 68, 38, 19, 37, 34, 46, 37, 63,\n 32, 21, 41, 43, 24, 41, 67, 26, 36, 46, 54, 61, 49, 35, 16, 16, 16, 56,\n 41, 41, 17, 40, 12, 46, 48, 19, 73, 31, 11, 52, 50, 26, 41, 55, 35, 23,\n 56, 22, 33, 60, 44, 23, 40, 23, 31, 43, 46, 26, 40, 40, 56, 29, 33, 24,\n 20, 53, 62, 22, 51, 68, 62, 56, 30, 56, 49, 64, 35, 39, 29, 36, 47, 24,\n 74, 36, 39, 54, 18, 21, 55, 34, 70, 24, 37, 31, 39, 63, 11, 42, 61, 31,\n 62, 46, 25, 38, 19, 53, 33, 26, 23, 52, 52, 36, 30, 10, 48, 58, 26, 29,\n 16, 23, 34, 22, 15, 26, 42, 15, 18, 46, 59, 58, 30, 42, 49, 16, 14, 50,\n 29, 27, 41, 48, 59, 42, 32, 33, 43, 43, 53, 52, 43, 63, 44, 19, 46, 43,\n 34, 50, 50, 23, 37, 36, 76, 50, 49, 54, 40, 35, 52, 42, 15, 32, 27, 22,\n 36, 26, 62, 31, 37, 50, 59, 35, 28, 18, 33, 39, 56, 44, 53, 39, 13, 12,\n 42, 44, 56, 58, 45, 31, 44, 74, 28, 46, 44, 31, 36, 40, 35, 41, 23, 34,\n 27, 27, 64, 39, 31, 51, 15, 38, 58, 41, 30, 31, 56, 44, 43, 41, 31, 10,\n 56, 66, 19, 54, 43, 35, 50, 40, 43, 50, 39, 19, 29, 17, 16, 46, 33, 11,\n 38, 47, 47, 33, 21, 45, 35, 37, 78, 69, 42, 59, 50, 30, 43, 50, 49, 29,\n 61, 46, 62, 25, 39, 67, 32, 43, 21, 26, 16, 26, 18, 55, 37, 33, 23, 33,\n 45, 47, 32, 51, 45, 23, 56, 49, 75, 28, 21, 34, 28, 40, 47, 34, 37, 43,\n 25, 31, 56, 65, 38, 14, 25, 33, 20, 7, 40, 39, 25, 56, 28, 51, 24, 52,\n 35, 46, 57, 52, 38, 56, 31, 18, 14, 20, 45, 36, 28, 24, 30, 50, 39, 43,\n 64, 31, 22, 48, 42, 42, 68, 51, 16, 37, 22, 43, 55, 22, 26, 41, 40, 29,\n 27, 35, 29, 59, 42, 50, 59, 31, 29, 52, 55, 30, 26, 30, 30, 39, 32, 40,\n 19, 45, 30, 32, 12, 52, 37, 26, 45, 36, 60, 58, 15, 9, 38, 38, 36, 44,\n 47, 27, 38, 46, 36, 44, 26, 28, 24, 32, 44, 14, 31, 62, 60, 61, 12, 45,\n 38, 55, 27, 30, 30, 70, 48, 38, 49, 33, 46, 47, 39, 43, 22, 29, 31, 37,\n 69, 14, 45, 81, 38, 45, 32, 13, 41, 7, 38, 44, 54, 45, 35, 13, 35, 53,\n 55, 25, 9, 15, 36, 40, 26, 35, 25, 45, 15, 55, 47, 22, 50, 29, 41, 35,\n 46, 25, 33, 23, 20, 35, 34, 31, 32, 29, 42, 46, 19, 60, 57, 31, 29, 31,\n 36, 50, 59, 51, 33, 31, 61, 64, 28, 58, 48, 43, 24, 33, 40, 43, 21, 48,\n 37, 44, 14, 31, 28, 41, 33, 50, 52, 59, 54, 50, 23, 47, 27, 28, 54, 44,\n 34, 28, 60, 46, 37, 29, 28, 54, 14, 26, 19, 41, 46, 31, 20, 74, 27, 31,\n 38, 48, 24, 48, 57, 72, 11, 43]}}\n\n\ndef l1_bound(items: Tuple[int, ...], capacity: int) -> float:\n \"\"\"Computes L1 lower bound on OPT for bin packing.\n\n Args:\n items: Tuple of items to pack into bins.\n capacity: Capacity of bins.\n\n Returns:\n Lower bound on number of bins required to pack items.\n \"\"\"\n return np.ceil(np.sum(items) / capacity)\n\n\ndef l1_bound_dataset(instances: dict) -> float:\n \"\"\"Computes the mean L1 lower bound across a dataset of bin packing instances.\n\n Args:\n instances: Dictionary containing a set of bin packing instances.\n\n Returns:\n Average L1 lower bound on number of bins required to pack items.\n \"\"\"\n l1_bounds = []\n for name in instances:\n instance = instances[name]\n l1_bounds.append(l1_bound(instance['items'], instance['capacity']))\n return np.mean(l1_bounds)\n\n\nopt_num_bins = {}\nfor name, dataset in datasets.items():\n opt_num_bins[name] = l1_bound_dataset(dataset)\n\n\nif __name__ == '__main__':\n print(datasets['OR3'].keys())" }, { "path": "baseline/funsearch/funsearch_bin_packing_llm_api.py", "content": "import json\nimport multiprocessing\nfrom typing import Collection, Any\nimport http.client\nfrom implementation import funsearch\nfrom implementation import config\nfrom implementation import sampler\nfrom implementation import evaluator_accelerate\nfrom implementation import evaluator\nfrom implementation import code_manipulation\nimport bin_packing_utils\n\nimport json\nimport multiprocessing\nfrom typing import Collection, Any\nimport http.client\nfrom implementation import sampler\n\n\ndef _trim_preface_of_body(sample: str) -> str:\n \"\"\"Trim the redundant descriptions/symbols/'def' declaration before the function body.\n Please see my comments in sampler.LLM (in sampler.py).\n Since the LLM used in this file is not a pure code completion LLM, this trim function is required.\n\n -Example sample (function & description generated by LLM):\n -------------------------------------\n This is the optimized function ...\n def priority_v2(...) -> ...:\n return ...\n This function aims to ...\n -------------------------------------\n -This function removes the description above the function's signature, and the function's signature.\n -The indent of the code is preserved.\n -Return of this function:\n -------------------------------------\n return ...\n This function aims to ...\n -------------------------------------\n \"\"\"\n lines = sample.splitlines()\n func_body_lineno = 0\n find_def_declaration = False\n for lineno, line in enumerate(lines):\n # find the first 'def' statement in the given code\n if line[:3] == 'def':\n func_body_lineno = lineno\n find_def_declaration = True\n break\n if find_def_declaration:\n code = ''\n for line in lines[func_body_lineno + 1:]:\n code += line + '\\n'\n return code\n return sample\n\n\nclass LLMAPI(sampler.LLM):\n \"\"\"Language model that predicts continuation of provided source code.\n \"\"\"\n\n def __init__(self, samples_per_prompt: int, trim=True):\n super().__init__(samples_per_prompt)\n additional_prompt = ('Complete a different and more complex Python function. '\n 'Be creative and you can insert multiple if-else and for-loop in the code logic.'\n 'Only output the Python code, no descriptions.')\n self._additional_prompt = additional_prompt\n self._trim = trim\n\n def draw_samples(self, prompt: str) -> Collection[str]:\n \"\"\"Returns multiple predicted continuations of `prompt`.\"\"\"\n return [self._draw_sample(prompt) for _ in range(self._samples_per_prompt)]\n\n def _draw_sample(self, content: str) -> str:\n prompt = '\\n'.join([content, self._additional_prompt])\n while True:\n try:\n conn = http.client.HTTPSConnection(\"api.chatanywhere.com.cn\")\n payload = json.dumps({\n \"max_tokens\": 512,\n \"model\": \"gpt-3.5-turbo\",\n \"messages\": [\n {\n \"role\": \"user\",\n \"content\": prompt\n }\n ]\n })\n headers = {\n 'Authorization': 'Bearer sk-ys02zx......(replace with your own)......',\n 'User-Agent': 'Apifox/1.0.0 (https://apifox.com)',\n 'Content-Type': 'application/json'\n }\n conn.request(\"POST\", \"/v1/chat/completions\", payload, headers)\n res = conn.getresponse()\n data = res.read().decode(\"utf-8\")\n data = json.loads(data)\n response = data['choices'][0]['message']['content']\n # trim function\n if self._trim:\n response = _trim_preface_of_body(response)\n return response\n except Exception:\n continue\n\n\nclass Sandbox(evaluator.Sandbox):\n \"\"\"Sandbox for executing generated code. Implemented by RZ.\n\n RZ: Sandbox returns the 'score' of the program and:\n 1) avoids the generated code to be harmful (accessing the internet, take up too much RAM).\n 2) stops the execution of the code in time (avoid endless loop).\n \"\"\"\n\n def __init__(self, verbose=False, numba_accelerate=True):\n \"\"\"\n Args:\n verbose : Print evaluate information.\n numba_accelerate: Use numba to accelerate the evaluation. It should be noted that not all numpy functions\n support numba acceleration, such as np.piecewise().\n \"\"\"\n self._verbose = verbose\n self._numba_accelerate = numba_accelerate\n\n def run(\n self,\n program: str,\n function_to_run: str, # RZ: refers to the name of the function to run (e.g., 'evaluate')\n function_to_evolve: str, # RZ: accelerate the code by decorating @numba.jit() on function_to_evolve.\n inputs: Any, # refers to the dataset\n test_input: str, # refers to the current instance\n timeout_seconds: int,\n **kwargs # RZ: add this\n ) -> tuple[Any, bool]:\n \"\"\"Returns `function_to_run(test_input)` and whether execution succeeded.\n\n RZ: If the generated code (generated by LLM) is executed successfully,\n the output of this function is the score of a given program.\n RZ: PLEASE NOTE THAT this SandBox is only designed for bin-packing problem.\n \"\"\"\n dataset = inputs[test_input]\n result_queue = multiprocessing.Queue()\n process = multiprocessing.Process(\n target=self._compile_and_run_function,\n args=(program, function_to_run, function_to_evolve, dataset, self._numba_accelerate, result_queue)\n )\n process.start()\n process.join(timeout=timeout_seconds)\n if process.is_alive():\n # if the process is not finished in time, we consider the program illegal\n process.terminate()\n process.join()\n results = None, False\n else:\n if not result_queue.empty():\n results = result_queue.get_nowait()\n else:\n results = None, False\n\n if self._verbose:\n print(f'================= Evaluated Program =================')\n program_: code_manipulation.Program = code_manipulation.text_to_program(text=program)\n func_to_evolve_: str = kwargs.get('func_to_evolve', 'priority')\n function_: code_manipulation.Function = program_.get_function(func_to_evolve_)\n function_: str = str(function_).strip('\\n')\n print(f'{function_}')\n print(f'-----------------------------------------------------')\n print(f'Score: {str(results)}')\n print(f'=====================================================')\n print(f'\\n\\n')\n\n return results\n\n def _compile_and_run_function(self, program, function_to_run, function_to_evolve, dataset, numba_accelerate,\n result_queue):\n try:\n # optimize the code (decorate function_to_run with @numba.jit())\n if numba_accelerate:\n program = evaluator_accelerate.add_numba_decorator(\n program=program,\n function_to_evolve=function_to_evolve\n )\n # compile the program, and maps the global func/var/class name to its address\n all_globals_namespace = {}\n # execute the program, map func/var/class to global namespace\n exec(program, all_globals_namespace)\n # get the pointer of 'function_to_run'\n function_to_run = all_globals_namespace[function_to_run]\n # return the execution results\n results = function_to_run(dataset)\n # the results must be int or float\n if not isinstance(results, (int, float)):\n result_queue.put((None, False))\n return\n result_queue.put((results, True))\n except:\n # if raise any exception, we assume the execution failed\n result_queue.put((None, False))\n\n\nspecification = r'''\nimport numpy as np\n\n\ndef get_valid_bin_indices(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns indices of bins in which item can fit.\"\"\"\n return np.nonzero((bins - item) >= 0)[0]\n\n\ndef online_binpack(\n items: tuple[float, ...], bins: np.ndarray\n) -> tuple[list[list[float, ...], ...], np.ndarray]:\n \"\"\"Performs online binpacking of `items` into `bins`.\"\"\"\n # Track which items are added to each bin.\n packing = [[] for _ in bins]\n # Add items to bins.\n for item in items:\n # Extract bins that have sufficient space to fit item.\n valid_bin_indices = get_valid_bin_indices(item, bins)\n # Score each bin based on heuristic.\n priorities = priority(item, bins[valid_bin_indices])\n # Add item to bin with highest priority.\n best_bin = valid_bin_indices[np.argmax(priorities)]\n bins[best_bin] -= item\n packing[best_bin].append(item)\n # Remove unused bins from packing.\n packing = [bin_items for bin_items in packing if bin_items]\n return packing, bins\n\n\n@funsearch.run\ndef evaluate(instances: dict) -> float:\n \"\"\"Evaluate heuristic function on a set of online binpacking instances.\"\"\"\n # List storing number of bins used for each instance.\n num_bins = []\n # Perform online binpacking for each instance.\n for name in instances:\n instance = instances[name]\n capacity = instance['capacity']\n items = instance['items']\n # Create num_items bins so there will always be space for all items,\n # regardless of packing order. Array has shape (num_items,).\n bins = np.array([capacity for _ in range(instance['num_items'])])\n # Pack items into bins and return remaining capacity in bins_packed, which\n # has shape (num_items,).\n _, bins_packed = online_binpack(items, bins)\n # If remaining capacity in a bin is equal to initial capacity, then it is\n # unused. Count number of used bins.\n num_bins.append((bins_packed != capacity).sum())\n # Score of heuristic function is negative of average number of bins used\n # across instances (as we want to minimize number of bins).\n return -np.mean(num_bins)\n\n\n@funsearch.evolve\ndef priority(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns priority with which we want to add item to each bin.\n\n Args:\n item: Size of item to be added to the bin.\n bins: Array of capacities for each bin.\n\n Return:\n Array of same size as bins with priority score of each bin.\n \"\"\"\n ratios = item / bins\n log_ratios = np.log(ratios)\n priorities = -log_ratios\n return priorities\n'''\n\n# It should be noted that the if __name__ == '__main__' is required.\n# Because the inner code uses multiprocess evaluation.\nif __name__ == '__main__':\n class_config = config.ClassConfig(llm_class=LLMAPI, sandbox_class=Sandbox)\n config = config.Config(samples_per_prompt=4)\n\n bin_packing_or3 = {'OR3': bin_packing_utils.datasets['OR3']}\n global_max_sample_num = 10 # if it is set to None, funsearch will execute an endless loop\n funsearch.main(\n specification=specification,\n inputs=bin_packing_or3,\n config=config,\n max_sample_nums=global_max_sample_num,\n class_config=class_config,\n log_dir='logs/funsearch_llm_api',\n )\n" }, { "path": "baseline/funsearch/funsearch_bin_packing_local_llm.py", "content": "import json\nimport multiprocessing\nfrom typing import Collection, Any\n\nimport requests\nfrom implementation import funsearch\nfrom implementation import config\nfrom implementation import sampler\nfrom implementation import evaluator_accelerate\nfrom implementation import evaluator\nfrom implementation import code_manipulation\nimport bin_packing_utils\n\n\ndef _trim_preface_of_body(sample: str) -> str:\n \"\"\"Trim the redundant descriptions/symbols/'def' declaration before the function body.\n Please see my comments in sampler.LLM (in sampler.py).\n Since the LLM used in this file is not a pure code completion LLM, this trim function is required.\n\n -Example sample (function & description generated by LLM):\n -------------------------------------\n This is the optimized function ...\n def priority_v2(...) -> ...:\n return ...\n This function aims to ...\n -------------------------------------\n -This function removes the description above the function's signature, and the function's signature.\n -The indent of the code is preserved.\n -Return of this function:\n -------------------------------------\n return ...\n This function aims to ...\n -------------------------------------\n \"\"\"\n lines = sample.splitlines()\n func_body_lineno = 0\n find_def_declaration = False\n for lineno, line in enumerate(lines):\n # find the first 'def' statement in the given code\n if line[:3] == 'def':\n func_body_lineno = lineno\n find_def_declaration = True\n break\n if find_def_declaration:\n code = ''\n for line in lines[func_body_lineno + 1:]:\n code += line + '\\n'\n return code\n return sample\n\n\nclass LocalLLM(sampler.LLM):\n \"\"\"Language model that predicts continuation of provided source code.\n \"\"\"\n\n def __init__(self, samples_per_prompt: int, batch_inference: bool = True, trim=True) -> None:\n \"\"\"\n Args:\n batch_inference: Use batch inference when sample functions. The batch size equals to the samples_per_prompt.\n \"\"\"\n super().__init__(samples_per_prompt)\n url = 'http://127.0.0.1:11011/completions'\n additional_prompt = ('Complete a different and more complex Python function. '\n 'Be creative and you can insert multiple if-else and for-loop in the code logic.'\n 'Only output the Python code, no descriptions.')\n self._batch_inference = batch_inference\n self._url = url\n self._additional_prompt = additional_prompt\n self._trim = trim\n\n def draw_samples(self, prompt: str) -> Collection[str]:\n \"\"\"Returns multiple predicted continuations of `prompt`.\n \"\"\"\n while True:\n try:\n all_samples = []\n if self._batch_inference:\n response = self._do_request(prompt)\n for res in response:\n all_samples.append(res)\n else:\n for _ in range(self._samples_per_prompt):\n response = self._do_request(prompt)\n all_samples.append(response)\n\n # trim samples\n if self._trim:\n all_samples = [_trim_preface_of_body(sample) for sample in all_samples]\n\n return all_samples\n except:\n continue\n\n def _do_request(self, content: str) -> str:\n content = content.strip('\\n').strip()\n # repeat the prompt for batch inference (inorder to decease the sample delay)\n repeat_prompt: int = self._samples_per_prompt if self._batch_inference else 1\n data = {\n 'prompt': content,\n 'repeat_prompt': repeat_prompt,\n 'params': {\n 'do_sample': True,\n 'temperature': None,\n 'top_k': None,\n 'top_p': None,\n 'add_special_tokens': False,\n 'skip_special_tokens': True,\n }\n }\n headers = {'Content-Type': 'application/json'}\n response = requests.post(self._url, data=json.dumps(data), headers=headers)\n if response.status_code == 200:\n response = response.json()[\"content\"]\n return response if self._batch_inference else response[0]\n\n\nclass Sandbox(evaluator.Sandbox):\n \"\"\"Sandbox for executing generated code. Implemented by RZ.\n\n RZ: Sandbox returns the 'score' of the program and:\n 1) avoids the generated code to be harmful (accessing the internet, take up too much RAM).\n 2) stops the execution of the code in time (avoid endless loop).\n \"\"\"\n\n def __init__(self, verbose=False, numba_accelerate=True):\n \"\"\"\n Args:\n verbose : Print evaluate information.\n numba_accelerate: Use numba to accelerate the evaluation. It should be noted that not all numpy functions\n support numba acceleration, such as np.piecewise().\n \"\"\"\n self._verbose = verbose\n self._numba_accelerate = numba_accelerate\n\n def run(\n self,\n program: str,\n function_to_run: str, # RZ: refers to the name of the function to run (e.g., 'evaluate')\n function_to_evolve: str, # RZ: accelerate the code by decorating @numba.jit() on function_to_evolve.\n inputs: Any, # refers to the dataset\n test_input: str, # refers to the current instance\n timeout_seconds: int,\n **kwargs # RZ: add this\n ) -> tuple[Any, bool]:\n \"\"\"Returns `function_to_run(test_input)` and whether execution succeeded.\n\n RZ: If the generated code (generated by LLM) is executed successfully,\n the output of this function is the score of a given program.\n RZ: PLEASE NOTE THAT this SandBox is only designed for bin-packing problem.\n \"\"\"\n dataset = inputs[test_input]\n result_queue = multiprocessing.Queue()\n process = multiprocessing.Process(\n target=self._compile_and_run_function,\n args=(program, function_to_run, function_to_evolve, dataset, self._numba_accelerate, result_queue)\n )\n process.start()\n process.join(timeout=timeout_seconds)\n if process.is_alive():\n # if the process is not finished in time, we consider the program illegal\n process.terminate()\n process.join()\n results = None, False\n else:\n if not result_queue.empty():\n results = result_queue.get_nowait()\n else:\n results = None, False\n\n if self._verbose:\n print(f'================= Evaluated Program =================')\n program_: code_manipulation.Program = code_manipulation.text_to_program(text=program)\n func_to_evolve_: str = kwargs.get('func_to_evolve', 'priority')\n function_: code_manipulation.Function = program_.get_function(func_to_evolve_)\n function_: str = str(function_).strip('\\n')\n print(f'{function_}')\n print(f'-----------------------------------------------------')\n print(f'Score: {str(results)}')\n print(f'=====================================================')\n print(f'\\n\\n')\n\n return results\n\n def _compile_and_run_function(self, program, function_to_run, function_to_evolve, dataset, numba_accelerate,\n result_queue):\n try:\n # optimize the code (decorate function_to_run with @numba.jit())\n if numba_accelerate:\n program = evaluator_accelerate.add_numba_decorator(\n program=program,\n function_to_evolve=function_to_evolve\n )\n # compile the program, and maps the global func/var/class name to its address\n all_globals_namespace = {}\n # execute the program, map func/var/class to global namespace\n exec(program, all_globals_namespace)\n # get the pointer of 'function_to_run'\n function_to_run = all_globals_namespace[function_to_run]\n # return the execution results\n results = function_to_run(dataset)\n # the results must be int or float\n if not isinstance(results, (int, float)):\n result_queue.put((None, False))\n return\n result_queue.put((results, True))\n except:\n # if raise any exception, we assume the execution failed\n result_queue.put((None, False))\n\n\nspecification = r'''\nimport numpy as np\n\n\ndef get_valid_bin_indices(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns indices of bins in which item can fit.\"\"\"\n return np.nonzero((bins - item) >= 0)[0]\n\n\ndef online_binpack(\n items: tuple[float, ...], bins: np.ndarray\n) -> tuple[list[list[float, ...], ...], np.ndarray]:\n \"\"\"Performs online binpacking of `items` into `bins`.\"\"\"\n # Track which items are added to each bin.\n packing = [[] for _ in bins]\n # Add items to bins.\n for item in items:\n # Extract bins that have sufficient space to fit item.\n valid_bin_indices = get_valid_bin_indices(item, bins)\n # Score each bin based on heuristic.\n priorities = priority(item, bins[valid_bin_indices])\n # Add item to bin with highest priority.\n best_bin = valid_bin_indices[np.argmax(priorities)]\n bins[best_bin] -= item\n packing[best_bin].append(item)\n # Remove unused bins from packing.\n packing = [bin_items for bin_items in packing if bin_items]\n return packing, bins\n\n\n@funsearch.run\ndef evaluate(instances: dict) -> float:\n \"\"\"Evaluate heuristic function on a set of online binpacking instances.\"\"\"\n # List storing number of bins used for each instance.\n num_bins = []\n # Perform online binpacking for each instance.\n for name in instances:\n instance = instances[name]\n capacity = instance['capacity']\n items = instance['items']\n # Create num_items bins so there will always be space for all items,\n # regardless of packing order. Array has shape (num_items,).\n bins = np.array([capacity for _ in range(instance['num_items'])])\n # Pack items into bins and return remaining capacity in bins_packed, which\n # has shape (num_items,).\n _, bins_packed = online_binpack(items, bins)\n # If remaining capacity in a bin is equal to initial capacity, then it is\n # unused. Count number of used bins.\n num_bins.append((bins_packed != capacity).sum())\n # Score of heuristic function is negative of average number of bins used\n # across instances (as we want to minimize number of bins).\n return -np.mean(num_bins)\n\n\n@funsearch.evolve\ndef priority(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns priority with which we want to add item to each bin.\n\n Args:\n item: Size of item to be added to the bin.\n bins: Array of capacities for each bin.\n\n Return:\n Array of same size as bins with priority score of each bin.\n \"\"\"\n ratios = item / bins\n log_ratios = np.log(ratios)\n priorities = -log_ratios\n return priorities\n'''\n\n# It should be noted that the if __name__ == '__main__' is required.\n# Because the inner code uses multiprocess evaluation.\nif __name__ == '__main__':\n class_config = config.ClassConfig(llm_class=LocalLLM, sandbox_class=Sandbox)\n config = config.Config(samples_per_prompt=4)\n\n bin_packing_or3 = {'OR3': bin_packing_utils.datasets['OR3']}\n global_max_sample_num = 10 # if it is set to None, funsearch will execute an endless loop\n funsearch.main(\n specification=specification,\n inputs=bin_packing_or3,\n config=config,\n max_sample_nums=global_max_sample_num,\n class_config=class_config,\n log_dir='logs/funsearch_local_llm',\n )\n" }, { "path": "baseline/funsearch/implementation/code_manipulation.py", "content": "# Copyright 2023 DeepMind Technologies Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n\"\"\"Tools for manipulating Python code.\n\nIt implements 2 classes representing unities of code:\n- Function, containing all the information we need about functions: name, args,\n body and optionally a return type and a docstring.\n- Program, which contains a code preface (which could be imports, global\n variables and classes, ...) and a list of Functions.\n\nRZ: The frequently used word 'call' in this file refers to the name of the function. For example the following:\ndef add_five(param) -> int:\n return param + 5\nThe 'call' of the function is 'add_file'.\n\"\"\"\nfrom __future__ import annotations\n\nimport ast\nfrom collections.abc import Iterator, MutableSet, Sequence\nimport dataclasses\nimport io\nimport tokenize\n\nfrom absl import logging\n\n\n@dataclasses.dataclass\nclass Function:\n \"\"\"A parsed Python function.\"\"\"\n\n name: str\n args: str\n body: str\n return_type: str | None = None\n docstring: str | None = None\n score: int | None = None # RZ: add this to record the score of the function.\n global_sample_nums: int | None = None # RZ: record the order of the current program in the sequence of samples taken.\n sample_time: float | None = None # RZ: add this\n evaluate_time: float | None = None # RZ: add this\n\n def __str__(self) -> str:\n return_type = f' -> {self.return_type}' if self.return_type else ''\n\n function = f'def {self.name}({self.args}){return_type}:\\n'\n if self.docstring:\n # self.docstring is already indented on every line except the first one.\n # Here, we assume the indentation is always two spaces. => RZ: two spaces is ugly, change to four\n # RZ: two spaces is ugly, change to four spaces.\n new_line = '\\n' if self.body else ''\n # function += f' \"\"\"{self.docstring}\"\"\"{new_line}' # two spaces indentation\n function += f' \"\"\"{self.docstring}\"\"\"{new_line}'\n # self.body is already indented.\n function += self.body + '\\n\\n'\n return function\n\n def __setattr__(self, name: str, value: str) -> None:\n # Ensure there aren't leading & trailing new lines in `body`.\n if name == 'body':\n value = value.strip('\\n')\n # Ensure there aren't leading & trailing quotes in `docstring``.\n if name == 'docstring' and value is not None:\n if '\"\"\"' in value:\n value = value.strip()\n value = value.replace('\"\"\"', '')\n super().__setattr__(name, value)\n\n\n@dataclasses.dataclass(frozen=True)\nclass Program:\n \"\"\"A parsed Python program.\"\"\"\n\n # `preface` is everything from the beginning of the code till the first\n # function is found.\n preface: str\n functions: list[Function]\n\n def __str__(self) -> str:\n program = f'{self.preface}\\n' if self.preface else ''\n program += '\\n'.join([str(f) for f in self.functions])\n return program\n\n def find_function_index(self, function_name: str) -> int:\n \"\"\"Returns the index of input function name.\"\"\"\n function_names = [f.name for f in self.functions]\n count = function_names.count(function_name)\n if count == 0:\n raise ValueError(\n f'function {function_name} does not exist in program:\\n{str(self)}'\n )\n if count > 1:\n raise ValueError(\n f'function {function_name} exists more than once in program:\\n'\n f'{str(self)}'\n )\n index = function_names.index(function_name)\n return index\n\n def get_function(self, function_name: str) -> Function:\n index = self.find_function_index(function_name)\n return self.functions[index]\n\n\nclass ProgramVisitor(ast.NodeVisitor):\n \"\"\"Parses code to collect all required information to produce a `Program`.\n\n Note that we do not store function decorators.\n \"\"\"\n\n def __init__(self, sourcecode: str):\n self._codelines: list[str] = sourcecode.splitlines()\n self._preface: str = ''\n self._functions: list[Function] = []\n self._current_function: str | None = None\n\n def visit_FunctionDef(self, # pylint: disable=invalid-name\n node: ast.FunctionDef) -> None:\n \"\"\"Collects all information about the function being parsed.\"\"\"\n if node.col_offset == 0: # We only care about first level functions.\n self._current_function = node.name\n\n # -------------------------------------------------------------------------\n # RZ: BUGS!!! 这里问题很大 没有考虑到一些极端的情况 例如解析到的第一个函数就有装饰器\n # 如果解析的第一个函数有装饰器 那么装饰器也会被保留在前面的代码片段中\n # 但在算法的流程中 这个装饰器是无效的 后续评估会报错\n # Here is an issue: some cases were not taken into consideration.\n # For instance, if the first parsed function has decorators,\n # these decorators will also be retained in the preceding code snippet.\n # However, in the algorithm's flow, these decorators are invalid,\n # leading to subsequent evaluations reporting errors.\n # -------------------------------------------------------------------------\n # if not self._functions:\n # self._preface = '\\n'.join(self._codelines[:node.lineno - 1])\n # -------------------------------------------------------------------------\n\n # TODO Fix bugs 判断下如果函数 is decorated, 找到装饰器的最小行号, 并只保留其上面的部分作为 preface\n if not self._functions:\n has_decorators = bool(node.decorator_list)\n if has_decorators:\n # find the minimum line number and retain the code above\n decorator_start_line = min(decorator.lineno for decorator in node.decorator_list)\n self._preface = '\\n'.join(self._codelines[:decorator_start_line - 1])\n else:\n self._preface = '\\n'.join(self._codelines[:node.lineno - 1])\n\n function_end_line = node.end_lineno\n body_start_line = node.body[0].lineno - 1\n # Extract the docstring.\n docstring = None\n if isinstance(node.body[0], ast.Expr) and isinstance(node.body[0].value, ast.Str):\n docstring = f' \"\"\"{ast.literal_eval(ast.unparse(node.body[0]))}\"\"\"'\n if len(node.body) > 1:\n body_start_line = node.body[1].lineno - 1\n else:\n body_start_line = function_end_line\n\n self._functions.append(Function(\n name=node.name,\n args=ast.unparse(node.args), # RZ: ast.unparse() failed in Python3.8. Let us try Python3.9\n return_type=ast.unparse(node.returns) if node.returns else None,\n docstring=docstring,\n body='\\n'.join(self._codelines[body_start_line:function_end_line]),\n ))\n self.generic_visit(node)\n\n def return_program(self) -> Program:\n return Program(preface=self._preface, functions=self._functions)\n\n\ndef text_to_program(text: str) -> Program:\n \"\"\"Returns Program object by parsing input text using Python AST.\n \"\"\"\n try:\n # We assume that the program is composed of some preface (e.g. imports,\n # classes, assignments, ...) followed by a sequence of functions.\n tree = ast.parse(text)\n visitor = ProgramVisitor(text)\n visitor.visit(tree)\n return visitor.return_program()\n except Exception as e:\n logging.warning('Failed parsing %s', text)\n raise e\n\n\ndef text_to_function(text: str) -> Function:\n \"\"\"Returns Function object by parsing input text using Python AST.\"\"\"\n program = text_to_program(text)\n if len(program.functions) != 1:\n raise ValueError(f'Only one function expected, got {len(program.functions)}'\n f':\\n{program.functions}')\n return program.functions[0]\n\n\ndef _tokenize(code: str) -> Iterator[tokenize.TokenInfo]:\n \"\"\"Transforms `code` into Python tokens.\"\"\"\n code_bytes = code.encode()\n code_io = io.BytesIO(code_bytes)\n return tokenize.tokenize(code_io.readline)\n\n\ndef _untokenize(tokens: Sequence[tokenize.TokenInfo]) -> str:\n \"\"\"Transforms a list of Python tokens into code.\"\"\"\n code_bytes = tokenize.untokenize(tokens)\n return code_bytes.decode()\n\n\ndef _yield_token_and_is_call(code: str) -> Iterator[tuple[tokenize.TokenInfo, bool]]:\n \"\"\"Yields each token with a bool indicating whether it is a function call.\n \"\"\"\n try:\n tokens = _tokenize(code)\n prev_token = None\n is_attribute_access = False\n for token in tokens:\n if (prev_token and # If the previous token exists and\n prev_token.type == tokenize.NAME and # it is a Python identifier\n token.type == tokenize.OP and # and the current token is a delimiter\n token.string == '('): # and in particular it is '('.\n yield prev_token, not is_attribute_access\n is_attribute_access = False\n else:\n if prev_token:\n is_attribute_access = (\n prev_token.type == tokenize.OP and prev_token.string == '.'\n )\n yield prev_token, False\n prev_token = token\n if prev_token:\n yield prev_token, False\n except Exception as e:\n logging.warning('Failed parsing %s', code)\n raise e\n\n\ndef rename_function_calls(code: str, source_name: str, target_name: str) -> str:\n \"\"\"Renames function calls from `source_name` to `target_name`.\n \"\"\"\n if source_name not in code:\n return code\n modified_tokens = []\n for token, is_call in _yield_token_and_is_call(code):\n if is_call and token.string == source_name:\n # Replace the function name token\n modified_token = tokenize.TokenInfo(\n type=token.type,\n string=target_name,\n start=token.start,\n end=token.end,\n line=token.line\n )\n modified_tokens.append(modified_token)\n else:\n modified_tokens.append(token)\n return _untokenize(modified_tokens)\n\n\ndef get_functions_called(code: str) -> MutableSet[str]:\n \"\"\"Returns the set of all functions called in `code`.\n \"\"\"\n return set(token.string for token, is_call in\n _yield_token_and_is_call(code) if is_call)\n\n\ndef yield_decorated(code: str, module: str, name: str) -> Iterator[str]:\n \"\"\"Yields names of functions decorated with `@module.name` in `code`.\n \"\"\"\n tree = ast.parse(code)\n for node in ast.walk(tree):\n if isinstance(node, ast.FunctionDef):\n for decorator in node.decorator_list:\n attribute = None\n if isinstance(decorator, ast.Attribute):\n attribute = decorator\n elif isinstance(decorator, ast.Call):\n attribute = decorator.func\n if (attribute is not None\n and attribute.value.id == module\n and attribute.attr == name):\n yield node.name\n" }, { "path": "baseline/funsearch/implementation/config.py", "content": "# Copyright 2023 DeepMind Technologies Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n\"\"\"Configuration of a FunSearch experiment.\"\"\"\nfrom __future__ import annotations\n\nimport dataclasses\nfrom typing import Type\n\nfrom implementation import sampler\nfrom implementation import evaluator\n\n\n@dataclasses.dataclass(frozen=True)\nclass ProgramsDatabaseConfig:\n \"\"\"Configuration of a ProgramsDatabase.\n\n Attributes:\n functions_per_prompt: Number of previous programs to include in prompts.\n num_islands: Number of islands to maintain as a diversity mechanism.\n reset_period: How often (in seconds) the weakest islands should be reset.\n cluster_sampling_temperature_init: Initial temperature for softmax sampling\n of clusters within an island.\n cluster_sampling_temperature_period: Period of linear decay of the cluster\n sampling temperature.\n \"\"\"\n functions_per_prompt: int = 2\n num_islands: int = 10\n reset_period: int = 4 * 60 * 60\n cluster_sampling_temperature_init: float = 0.1\n cluster_sampling_temperature_period: int = 30_000\n\n\n@dataclasses.dataclass(frozen=True)\nclass Config:\n \"\"\"Configuration of a FunSearch experiment.\n\n Attributes:\n programs_database: Configuration of the evolutionary algorithm.\n num_samplers: Number of independent Samplers in the experiment. A value\n larger than 1 only has an effect when the samplers are able to execute\n in parallel, e.g. on different machines of a distributed system.\n num_evaluators: Number of independent program Evaluators in the experiment.\n A value larger than 1 is only expected to be useful when the Evaluators\n can execute in parallel as part of a distributed system.\n samples_per_prompt: How many independently sampled program continuations to\n obtain for each prompt.\n \"\"\"\n programs_database: ProgramsDatabaseConfig = dataclasses.field(default_factory=ProgramsDatabaseConfig)\n num_samplers: int = 1 # RZ: I just use one samplers\n # num_evaluators: int = 140\n num_evaluators: int = 1 # RZ: I just use one evaluators\n samples_per_prompt: int = 4\n\n\n@dataclasses.dataclass()\nclass ClassConfig:\n \"\"\"Implemented by RZ. Configuration of 'class LLM' and 'class SandBox' used in this implementation.\n \"\"\"\n llm_class: Type[sampler.LLM]\n sandbox_class: Type[evaluator.Sandbox]\n" }, { "path": "baseline/funsearch/implementation/evaluator.py", "content": "# Copyright 2023 DeepMind Technologies Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n\"\"\"Class for evaluating programs proposed by the Sampler.\"\"\"\nfrom __future__ import annotations\n\nfrom abc import abstractmethod, ABC\nimport ast\nimport time\nfrom collections.abc import Sequence\nimport copy\nfrom typing import Any, Type\nimport profile\n\nfrom implementation import code_manipulation\nfrom implementation import programs_database\n\n\nclass _FunctionLineVisitor(ast.NodeVisitor):\n \"\"\"Visitor that finds the last line number of a function with a given name.\"\"\"\n\n def __init__(self, target_function_name: str) -> None:\n self._target_function_name: str = target_function_name\n self._function_end_line: int | None = None\n\n def visit_FunctionDef(self, node: Any) -> None: # pylint: disable=invalid-name\n \"\"\"Collects the end line number of the target function.\"\"\"\n if node.name == self._target_function_name:\n self._function_end_line = node.end_lineno\n self.generic_visit(node)\n\n @property\n def function_end_line(self) -> int:\n \"\"\"Line number of the final line of function `target_function_name`.\"\"\"\n assert self._function_end_line is not None # Check internal correctness.\n return self._function_end_line\n\n\ndef _trim_function_body(generated_code: str) -> str:\n \"\"\"Extracts the body of the generated function, trimming anything after it.\n\n RZ: the arg generated_code must only include the body of the generated function (an example is shown below):\n --------------\n a = item\n return a\n --------------\n Please note that the indentation is REQUIRED !!!\n \"\"\"\n if not generated_code:\n return ''\n\n code = f'def fake_function_header():\\n{generated_code}'\n\n tree = None\n # We keep trying and deleting code from the end until the parser succeeds.\n while tree is None:\n try:\n tree = ast.parse(code)\n except SyntaxError as e:\n # RZ: \"e.lineno - 1\" locates the line number of the lost python code\n code = '\\n'.join(code.splitlines()[:e.lineno - 1])\n\n if not code:\n # Nothing could be saved from `generated_code`\n return ''\n\n visitor = _FunctionLineVisitor('fake_function_header')\n visitor.visit(tree)\n body_lines = code.splitlines()[1:visitor.function_end_line]\n return '\\n'.join(body_lines) + '\\n\\n'\n\n\ndef _sample_to_program(\n generated_code: str,\n version_generated: int | None,\n template: code_manipulation.Program,\n function_to_evolve: str,\n) -> tuple[code_manipulation.Function, str]:\n \"\"\"Returns the compiled generated function and the full runnable program.\n RZ: This function removes the code after the generated function body.\n \"\"\"\n body = _trim_function_body(generated_code)\n if version_generated is not None:\n body = code_manipulation.rename_function_calls(\n code=body,\n source_name=f'{function_to_evolve}_v{version_generated}',\n target_name=function_to_evolve\n )\n\n program = copy.deepcopy(template)\n evolved_function = program.get_function(function_to_evolve)\n evolved_function.body = body\n return evolved_function, str(program)\n\n\nclass Sandbox(ABC):\n \"\"\"Sandbox for executing generated code.\n RZ: Sandbox 1) avoids the generated code to be harmful (accessing the internet, take up too much RAM).\n 2) stops the execution of the code in time (avoid endless loop).\n \"\"\"\n\n @abstractmethod\n def run(\n self,\n program: str,\n function_to_run: str,\n function_to_evolve: str,\n inputs: Any, # refers to the full dataset, added by RZ\n test_input: str, # refers to the current instance\n timeout_seconds: int,\n **kwargs\n ) -> tuple[Any, bool]:\n \"\"\"Returns `function_to_run(test_input)` and whether execution succeeded.\n RZ: If the generated code (generated by LLM) is executed successfully, the output of this function\n \"\"\"\n raise NotImplementedError(\n 'Must provide a sandbox for executing untrusted code.')\n\n\ndef _calls_ancestor(program: str, function_to_evolve: str) -> bool:\n \"\"\"Returns whether the generated function is calling an earlier version.\"\"\"\n for name in code_manipulation.get_functions_called(program):\n # In `program` passed into this function the most recently generated\n # function has already been renamed to `function_to_evolve` (wihout the\n # suffix). Therefore, any function call starting with `function_to_evolve_v`\n # is a call to an ancestor function.\n if name.startswith(f'{function_to_evolve}_v'):\n return True\n return False\n\n\nclass Evaluator:\n \"\"\"Class that analyses functions generated by LLMs.\"\"\"\n\n def __init__(\n self,\n database: programs_database.ProgramsDatabase,\n template: code_manipulation.Program,\n function_to_evolve: str, # RZ: refers to the name of the function to evolve (e.g., 'priority')\n function_to_run: str, # RZ: refers to the name of the function to run (e.g., 'evaluate')\n inputs: Sequence[Any], # RZ: I guess this refers to the evaluate instance\n timeout_seconds: int = 30,\n sandbox_class: Type[Sandbox] = Sandbox\n ):\n self._database = database\n self._template = template\n self._function_to_evolve = function_to_evolve\n self._function_to_run = function_to_run\n self._inputs = inputs\n self._timeout_seconds = timeout_seconds\n self._sandbox = sandbox_class()\n\n def analyse(\n self,\n sample: str,\n island_id: int | None,\n version_generated: int | None,\n **kwargs # RZ: add this to do profile\n ) -> None:\n \"\"\"Compiles the sample into a program and executes it on test inputs.\n\n Args:\n sample: RZ: please note that the sample must be preprocessed--only have function body,\n no description before it (except annotations), no symbols before it.\n Or the \"_sample_to_program\" function will fail!!!\n \"\"\"\n # RZ: 'new_function' refers to the evolved function ('def' statement + function body)\n # RZ: 'program' is the template code + new_function\n new_function, program = _sample_to_program(\n sample, version_generated, self._template, self._function_to_evolve)\n scores_per_test = {}\n\n time_reset = time.time()\n for current_input in self._inputs:\n # RZ: IMPORTANT !!! if self._inputs is a dict,\n # current_input is a key (perhaps in string type)\n # do not ignore this when implementing SandBox !!!\n\n test_output, runs_ok = self._sandbox.run(\n program, self._function_to_run, self._function_to_evolve, self._inputs, current_input,\n self._timeout_seconds\n )\n\n if runs_ok and not _calls_ancestor(program, self._function_to_evolve) and test_output is not None:\n if not isinstance(test_output, (int, float)):\n print(f'RZ=> Error: test_output is {test_output}')\n raise ValueError('@function.run did not return an int/float score.')\n scores_per_test[current_input] = test_output\n\n evaluate_time = time.time() - time_reset\n\n # RZ: If 'score_per_test' is not empty, the score of the program will be recorded to the profiler by the 'register_program'.\n # This is because the register_program will do reduction for a given Function score.\n # If 'score_per_test' is empty, we record it to the profiler at once.\n if scores_per_test:\n self._database.register_program(\n new_function,\n island_id,\n scores_per_test,\n **kwargs,\n evaluate_time=evaluate_time\n )\n else:\n profiler: profile.Profiler = kwargs.get('profiler', None)\n if profiler:\n global_sample_nums = kwargs.get('global_sample_nums', None)\n sample_time = kwargs.get('sample_time', None)\n new_function.global_sample_nums = global_sample_nums\n new_function.score = None\n new_function.sample_time = sample_time\n new_function.evaluate_time = evaluate_time\n profiler.register_function(new_function)\n" }, { "path": "baseline/funsearch/implementation/evaluator_accelerate.py", "content": "# Implemented by RZ.\n# This file aims to accelerate the original evaluate logic using 'numba' package.\n# You should install numba package in your Python environment or the later evaluation will fail.\n\nimport ast\n\n\ndef add_numba_decorator(\n program: str,\n function_to_evolve: str,\n) -> str:\n \"\"\"\n This function aims to accelerate the evaluation of the searched code. This is achieved by decorating '@numba.jit()'\n to the function_to_evolve. However, it should be noted that not all numpy functions support numba acceleration:\n such as np.piecewise(). So use this function wisely. Hahaha!\n\n Example input program:\n def func(a: np.ndarray):\n return a * 2\n Example output program\n import numba\n\n numba.jit()\n def func(a: np.ndarray):\n return a * 2\n \"\"\"\n # parse to syntax tree\n tree = ast.parse(program)\n\n # check if 'import numba' already exists\n numba_imported = False\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == 'numba' for alias in node.names):\n numba_imported = True\n break\n\n # add 'import numba' to the top of the program\n if not numba_imported:\n import_node = ast.Import(names=[ast.alias(name='numba', asname=None)])\n tree.body.insert(0, import_node)\n\n # traverse the tree, and find the function_to_run\n for node in ast.walk(tree):\n if isinstance(node, ast.FunctionDef) and node.name == function_to_evolve:\n # the @numba.jit() decorator instance\n decorator = ast.Call(\n func=ast.Attribute(\n value=ast.Name(id='numba', ctx=ast.Load()),\n attr='jit',\n ctx=ast.Load()\n ),\n args=[], # args do not have argument name\n keywords=[ast.keyword(arg='nopython', value=ast.NameConstant(value=True))]\n # keywords have argument name\n )\n # add the decorator to the decorator_list of the node\n node.decorator_list.append(decorator)\n\n # turn the tree to string and return\n modified_program = ast.unparse(tree)\n return modified_program\n\n\nif __name__ == '__main__':\n code = '''\nimport numpy as np\nimport numba\n\ndef func1():\n return 3\n\ndef func():\n return 5\n '''\n res = add_numba_decorator(code, 'func')\n print(res)\n" }, { "path": "baseline/funsearch/implementation/funsearch.py", "content": "# Copyright 2023 DeepMind Technologies Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n\"\"\"A single-threaded implementation of the FunSearch pipeline.\"\"\"\nfrom __future__ import annotations\n\n# from collections.abc import Sequence\n\n# RZ: there are multiple errors in the original code\n# we should use typing.xxx rather than collections.abc.xxx\nfrom typing import Any, Tuple, Sequence\n\nfrom implementation import code_manipulation\nfrom implementation import config as config_lib\nfrom implementation import evaluator\nfrom implementation import programs_database\nfrom implementation import sampler\nfrom implementation import profile\n\n\ndef _extract_function_names(specification: str) -> Tuple[str, str]:\n \"\"\"Returns the name of the function to evolve and of the function to run.\n\n RZ: The so-called specification refers to the boilerplate code template for a task.\n The template MUST have two important functions decorated with '@funsearch.run', '@funsearch.evolve' respectively.\n The function labeled with '@funsearch.run' is going to evaluate the generated code (like fitness evaluation).\n The function labeled with '@funsearch.evolve' is the function to be searched (like 'greedy' in cap-set).\n This function (_extract_function_names) makes sure that these decorators appears in the specification.\n \"\"\"\n run_functions = list(code_manipulation.yield_decorated(specification, 'funsearch', 'run'))\n if len(run_functions) != 1:\n raise ValueError('Expected 1 function decorated with `@funsearch.run`.')\n evolve_functions = list(code_manipulation.yield_decorated(specification, 'funsearch', 'evolve'))\n if len(evolve_functions) != 1:\n raise ValueError('Expected 1 function decorated with `@funsearch.evolve`.')\n return evolve_functions[0], run_functions[0]\n\n\ndef main(\n specification: str,\n inputs: Sequence[Any],\n config: config_lib.Config,\n max_sample_nums: int | None,\n class_config: config_lib.ClassConfig,\n **kwargs\n):\n \"\"\"Launches a FunSearch experiment.\n RZ:\n Args:\n specification: the boilerplate code for the problem.\n inputs : the data instances for the problem (see 'bin_packing_utils.py').\n config : config file.\n max_sample_nums: the maximum samples nums from LLM. 'None' refers to no stop.\n \"\"\"\n function_to_evolve, function_to_run = _extract_function_names(specification)\n template = code_manipulation.text_to_program(specification)\n database = programs_database.ProgramsDatabase(config.programs_database, template, function_to_evolve)\n\n # get log_dir and create profiler\n log_dir = kwargs.get('log_dir', None)\n if log_dir is None:\n profiler = None\n else:\n profiler = profile.Profiler(log_dir)\n\n evaluators = []\n for _ in range(config.num_evaluators):\n evaluators.append(evaluator.Evaluator(\n database,\n template,\n function_to_evolve,\n function_to_run,\n inputs,\n sandbox_class=class_config.sandbox_class\n ))\n\n # We send the initial implementation to be analysed by one of the evaluators.\n initial = template.get_function(function_to_evolve).body\n evaluators[0].analyse(initial, island_id=None, version_generated=None, profiler=profiler)\n\n # Set global max sample nums.\n samplers = [sampler.Sampler(database, evaluators, config.samples_per_prompt, max_sample_nums=max_sample_nums, llm_class=class_config.llm_class)\n for _ in range(config.num_samplers)]\n\n # This loop can be executed in parallel on remote sampler machines. As each\n # sampler enters an infinite loop, without parallelization only the first\n # sampler will do any work.\n for s in samplers:\n s.sample(profiler=profiler)\n" }, { "path": "baseline/funsearch/implementation/profile.py", "content": "# implemented by RZ\n# profile the experiment using tensorboard\n\nfrom __future__ import annotations\n\nimport os.path\nfrom typing import List, Dict\nimport logging\nimport json\nfrom implementation import code_manipulation\nfrom torch.utils.tensorboard import SummaryWriter\n\n\n\nclass Profiler:\n def __init__(\n self,\n log_dir: str | None = None,\n pkl_dir: str | None = None,\n max_log_nums: int | None = None,\n ):\n \"\"\"\n Args:\n log_dir : folder path for tensorboard log files.\n pkl_dir : save the results to a pkl file.\n max_log_nums: stop logging if exceeding max_log_nums.\n \"\"\"\n logging.getLogger().setLevel(logging.INFO)\n self._log_dir = log_dir\n self._json_dir = os.path.join(log_dir, 'samples')\n os.makedirs(self._json_dir, exist_ok=True)\n # self._pkl_dir = pkl_dir\n self._max_log_nums = max_log_nums\n self._num_samples = 0\n self._cur_best_program_sample_order = None\n self._cur_best_program_score = -99999999\n self._evaluate_success_program_num = 0\n self._evaluate_failed_program_num = 0\n self._tot_sample_time = 0\n self._tot_evaluate_time = 0\n self._all_sampled_functions: Dict[int, code_manipulation.Function] = {}\n\n if log_dir:\n self._writer = SummaryWriter(log_dir=log_dir)\n\n self._each_sample_best_program_score = []\n self._each_sample_evaluate_success_program_num = []\n self._each_sample_evaluate_failed_program_num = []\n self._each_sample_tot_sample_time = []\n self._each_sample_tot_evaluate_time = []\n\n def _write_tensorboard(self):\n if not self._log_dir:\n return\n\n self._writer.add_scalar(\n 'Best Score of Function',\n self._cur_best_program_score,\n global_step=self._num_samples\n )\n self._writer.add_scalars(\n 'Legal/Illegal Function',\n {\n 'legal function num': self._evaluate_success_program_num,\n 'illegal function num': self._evaluate_failed_program_num\n },\n global_step=self._num_samples\n )\n self._writer.add_scalars(\n 'Total Sample/Evaluate Time',\n {'sample time': self._tot_sample_time, 'evaluate time': self._tot_evaluate_time},\n global_step=self._num_samples\n )\n\n def _write_json(self, programs: code_manipulation.Function):\n sample_order = programs.global_sample_nums\n sample_order = sample_order if sample_order is not None else 0\n function_str = str(programs)\n score = programs.score\n content = {\n 'sample_order': sample_order,\n 'function': function_str,\n 'score': score\n }\n path = os.path.join(self._json_dir, f'samples_{sample_order}.json')\n with open(path, 'w') as json_file:\n json.dump(content, json_file)\n\n def register_function(self, programs: code_manipulation.Function):\n if self._max_log_nums is not None and self._num_samples >= self._max_log_nums:\n return\n\n sample_orders: int = programs.global_sample_nums\n if sample_orders not in self._all_sampled_functions:\n self._num_samples += 1\n self._all_sampled_functions[sample_orders] = programs\n self._record_and_verbose(sample_orders)\n self._write_tensorboard()\n self._write_json(programs)\n\n def _record_and_verbose(self, sample_orders: int):\n function = self._all_sampled_functions[sample_orders]\n # function_name = function.name\n # function_body = function.body.strip('\\n')\n function_str = str(function).strip('\\n')\n sample_time = function.sample_time\n evaluate_time = function.evaluate_time\n score = function.score\n # log attributes of the function\n print(f'================= Evaluated Function =================')\n print(f'{function_str}')\n print(f'------------------------------------------------------')\n print(f'Score : {str(score)}')\n print(f'Sample time : {str(sample_time)}')\n print(f'Evaluate time: {str(evaluate_time)}')\n print(f'Sample orders: {str(sample_orders)}')\n print(f'======================================================\\n\\n')\n\n # update best function\n if function.score is not None and score > self._cur_best_program_score:\n self._cur_best_program_score = score\n self._cur_best_program_sample_order = sample_orders\n\n # update statistics about function\n if score:\n self._evaluate_success_program_num += 1\n else:\n self._evaluate_failed_program_num += 1\n\n if sample_time:\n self._tot_sample_time += sample_time\n if evaluate_time:\n self._tot_evaluate_time += evaluate_time\n\n # update ...\n # self._each_sample_best_program_score.append(self._cur_best_program_score)\n # self._each_sample_evaluate_success_program_num.append(self._evaluate_success_program_num)\n # self._each_sample_evaluate_failed_program_num.append(self._evaluate_failed_program_num)\n # self._each_sample_tot_sample_time.append(self._tot_sample_time)\n # self._each_sample_tot_evaluate_time.append(self._tot_evaluate_time)\n" }, { "path": "baseline/funsearch/implementation/programs_database.py", "content": "# Copyright 2023 DeepMind Technologies Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n\"\"\"A programs database that implements the evolutionary algorithm.\"\"\"\nfrom __future__ import annotations\n\nimport profile\nfrom collections.abc import Mapping, Sequence\nimport copy\nimport dataclasses\nimport time\nfrom typing import Any, Tuple, Mapping\n\nfrom absl import logging\nimport numpy as np\nimport scipy\n\nfrom implementation import code_manipulation\nfrom implementation import config as config_lib\n\n# RZ: I change the original code \"tuple[float, ...]\" to \"Tuple[float, ...]\"\nSignature = Tuple[float, ...]\n\n# RZ: the code is also incorrect\n# We should use typing.Mapping rather than abc.Mapping\nScoresPerTest = Mapping[Any, float]\n\n\ndef _softmax(logits: np.ndarray, temperature: float) -> np.ndarray:\n \"\"\"Returns the tempered softmax of 1D finite `logits`.\"\"\"\n if not np.all(np.isfinite(logits)):\n non_finites = set(logits[~np.isfinite(logits)])\n raise ValueError(f'`logits` contains non-finite value(s): {non_finites}')\n if not np.issubdtype(logits.dtype, np.floating):\n logits = np.array(logits, dtype=np.float32)\n\n result = scipy.special.softmax(logits / temperature, axis=-1)\n # Ensure that probabilities sum to 1 to prevent error in `np.random.choice`.\n index = np.argmax(result)\n result[index] = 1 - np.sum(result[0:index]) - np.sum(result[index + 1:])\n return result\n\n\ndef _reduce_score(scores_per_test: ScoresPerTest) -> float:\n \"\"\"Reduces per-test scores into a single score.\n \"\"\"\n # TODO RZ: change the code to average the score of each test.\n # return scores_per_test[list(scores_per_test.keys())[-1]]\n test_scores = [scores_per_test[k] for k in scores_per_test.keys()]\n return sum(test_scores) / len(test_scores)\n\n\ndef _get_signature(scores_per_test: ScoresPerTest) -> Signature:\n \"\"\"Represents test scores as a canonical signature.\"\"\"\n return tuple(scores_per_test[k] for k in sorted(scores_per_test.keys()))\n\n\n@dataclasses.dataclass(frozen=True)\nclass Prompt:\n \"\"\"A prompt produced by the ProgramsDatabase, to be sent to Samplers.\n\n Attributes:\n code: The prompt, ending with the header of the function to be completed.\n version_generated: The function to be completed is `_v{version_generated}`.\n island_id: Identifier of the island that produced the implementations\n included in the prompt. Used to direct the newly generated implementation\n into the same island.\n \"\"\"\n code: str\n version_generated: int\n island_id: int\n\n\nclass ProgramsDatabase:\n \"\"\"A collection of programs, organized as islands.\"\"\"\n\n def __init__(\n self,\n config: config_lib.ProgramsDatabaseConfig,\n template: code_manipulation.Program,\n function_to_evolve: str,\n ) -> None:\n self._config: config_lib.ProgramsDatabaseConfig = config\n self._template: code_manipulation.Program = template\n self._function_to_evolve: str = function_to_evolve\n\n # Initialize empty islands.\n self._islands: list[Island] = []\n for _ in range(config.num_islands):\n self._islands.append(\n Island(template, function_to_evolve, config.functions_per_prompt,\n config.cluster_sampling_temperature_init,\n config.cluster_sampling_temperature_period))\n self._best_score_per_island: list[float] = (\n [-float('inf')] * config.num_islands)\n self._best_program_per_island: list[code_manipulation.Function | None] = (\n [None] * config.num_islands)\n self._best_scores_per_test_per_island: list[ScoresPerTest | None] = (\n [None] * config.num_islands)\n\n self._last_reset_time: float = time.time()\n\n def get_prompt(self) -> Prompt:\n \"\"\"Returns a prompt containing implementations from one chosen island.\"\"\"\n island_id = np.random.randint(len(self._islands))\n code, version_generated = self._islands[island_id].get_prompt()\n return Prompt(code, version_generated, island_id)\n\n def _register_program_in_island(\n self,\n program: code_manipulation.Function,\n island_id: int,\n scores_per_test: ScoresPerTest,\n **kwargs # RZ: add this for profiling\n ) -> None:\n \"\"\"Registers `program` in the specified island.\"\"\"\n self._islands[island_id].register_program(program, scores_per_test)\n score = _reduce_score(scores_per_test)\n if score > self._best_score_per_island[island_id]:\n self._best_program_per_island[island_id] = program\n self._best_scores_per_test_per_island[island_id] = scores_per_test\n self._best_score_per_island[island_id] = score\n logging.info('Best score of island %d increased to %s', island_id, score)\n\n # ======== RZ: profiling ========\n profiler: profile.Profiler = kwargs.get('profiler', None)\n if profiler:\n global_sample_nums = kwargs.get('global_sample_nums', None)\n sample_time = kwargs.get('sample_time', None)\n evaluate_time = kwargs.get('evaluate_time', None)\n program.score = score\n program.global_sample_nums = global_sample_nums\n program.sample_time = sample_time\n program.evaluate_time = evaluate_time\n profiler.register_function(program)\n\n def register_program(\n self,\n program: code_manipulation.Function,\n island_id: int | None,\n scores_per_test: ScoresPerTest,\n **kwargs # RZ: add this for profiling\n ) -> None:\n \"\"\"Registers `program` in the database.\"\"\"\n # In an asynchronous implementation we should consider the possibility of\n # registering a program on an island that had been reset after the prompt\n # was generated. Leaving that out here for simplicity.\n if island_id is None:\n # This is a program added at the beginning, so adding it to all islands.\n for island_id in range(len(self._islands)):\n self._register_program_in_island(program, island_id, scores_per_test, **kwargs)\n else:\n self._register_program_in_island(program, island_id, scores_per_test, **kwargs)\n\n # Check whether it is time to reset an island.\n if time.time() - self._last_reset_time > self._config.reset_period:\n self._last_reset_time = time.time()\n self.reset_islands()\n\n def reset_islands(self) -> None:\n \"\"\"Resets the weaker half of islands.\"\"\"\n # We sort best scores after adding minor noise to break ties.\n indices_sorted_by_score: np.ndarray = np.argsort(\n self._best_score_per_island +\n np.random.randn(len(self._best_score_per_island)) * 1e-6)\n num_islands_to_reset = self._config.num_islands // 2\n reset_islands_ids = indices_sorted_by_score[:num_islands_to_reset]\n keep_islands_ids = indices_sorted_by_score[num_islands_to_reset:]\n for island_id in reset_islands_ids:\n self._islands[island_id] = Island(\n self._template,\n self._function_to_evolve,\n self._config.functions_per_prompt,\n self._config.cluster_sampling_temperature_init,\n self._config.cluster_sampling_temperature_period)\n self._best_score_per_island[island_id] = -float('inf')\n founder_island_id = np.random.choice(keep_islands_ids)\n founder = self._best_program_per_island[founder_island_id]\n founder_scores = self._best_scores_per_test_per_island[founder_island_id]\n self._register_program_in_island(founder, island_id, founder_scores)\n\n\nclass Island:\n \"\"\"A sub-population of the programs database.\"\"\"\n\n def __init__(\n self,\n template: code_manipulation.Program,\n function_to_evolve: str,\n functions_per_prompt: int,\n cluster_sampling_temperature_init: float,\n cluster_sampling_temperature_period: int,\n ) -> None:\n self._template: code_manipulation.Program = template\n self._function_to_evolve: str = function_to_evolve\n self._functions_per_prompt: int = functions_per_prompt\n self._cluster_sampling_temperature_init = cluster_sampling_temperature_init\n self._cluster_sampling_temperature_period = (\n cluster_sampling_temperature_period)\n\n self._clusters: dict[Signature, Cluster] = {}\n self._num_programs: int = 0\n\n def register_program(\n self,\n program: code_manipulation.Function,\n scores_per_test: ScoresPerTest,\n ) -> None:\n \"\"\"Stores a program on this island, in its appropriate cluster.\"\"\"\n signature = _get_signature(scores_per_test)\n if signature not in self._clusters:\n score = _reduce_score(scores_per_test)\n self._clusters[signature] = Cluster(score, program)\n else:\n self._clusters[signature].register_program(program)\n self._num_programs += 1\n\n def get_prompt(self) -> tuple[str, int]:\n \"\"\"Constructs a prompt containing functions from this island.\"\"\"\n signatures = list(self._clusters.keys())\n cluster_scores = np.array(\n [self._clusters[signature].score for signature in signatures])\n\n # Convert scores to probabilities using softmax with temperature schedule.\n period = self._cluster_sampling_temperature_period\n temperature = self._cluster_sampling_temperature_init * (\n 1 - (self._num_programs % period) / period)\n probabilities = _softmax(cluster_scores, temperature)\n\n # At the beginning of an experiment when we have few clusters, place fewer\n # programs into the prompt.\n functions_per_prompt = min(len(self._clusters), self._functions_per_prompt)\n\n idx = np.random.choice(\n len(signatures), size=functions_per_prompt, p=probabilities)\n chosen_signatures = [signatures[i] for i in idx]\n implementations = []\n scores = []\n for signature in chosen_signatures:\n cluster = self._clusters[signature]\n implementations.append(cluster.sample_program())\n scores.append(cluster.score)\n\n indices = np.argsort(scores)\n sorted_implementations = [implementations[i] for i in indices]\n version_generated = len(sorted_implementations) + 1\n return self._generate_prompt(sorted_implementations), version_generated\n\n def _generate_prompt(\n self,\n implementations: Sequence[code_manipulation.Function]) -> str:\n \"\"\"Creates a prompt containing a sequence of function `implementations`.\"\"\"\n implementations = copy.deepcopy(implementations) # We will mutate these.\n\n # Format the names and docstrings of functions to be included in the prompt.\n versioned_functions: list[code_manipulation.Function] = []\n for i, implementation in enumerate(implementations):\n new_function_name = f'{self._function_to_evolve}_v{i}'\n implementation.name = new_function_name\n # Update the docstring for all subsequent functions after `_v0`.\n if i >= 1:\n implementation.docstring = (\n f'Improved version of `{self._function_to_evolve}_v{i - 1}`.')\n # If the function is recursive, replace calls to itself with its new name.\n implementation = code_manipulation.rename_function_calls(\n str(implementation), self._function_to_evolve, new_function_name)\n versioned_functions.append(\n code_manipulation.text_to_function(implementation))\n\n # Create the header of the function to be generated by the LLM.\n next_version = len(implementations)\n new_function_name = f'{self._function_to_evolve}_v{next_version}'\n header = dataclasses.replace(\n implementations[-1],\n name=new_function_name,\n body='',\n docstring=('Improved version of '\n f'`{self._function_to_evolve}_v{next_version - 1}`.'),\n )\n versioned_functions.append(header)\n\n # Replace functions in the template with the list constructed here.\n prompt = dataclasses.replace(self._template, functions=versioned_functions)\n return str(prompt)\n\n\nclass Cluster:\n \"\"\"A cluster of programs on the same island and with the same Signature.\"\"\"\n\n def __init__(self, score: float, implementation: code_manipulation.Function):\n self._score = score\n self._programs: list[code_manipulation.Function] = [implementation]\n self._lengths: list[int] = [len(str(implementation))]\n\n @property\n def score(self) -> float:\n \"\"\"Reduced score of the signature that this cluster represents.\"\"\"\n return self._score\n\n def register_program(self, program: code_manipulation.Function) -> None:\n \"\"\"Adds `program` to the cluster.\"\"\"\n self._programs.append(program)\n self._lengths.append(len(str(program)))\n\n def sample_program(self) -> code_manipulation.Function:\n \"\"\"Samples a program, giving higher probability to shorther programs.\"\"\"\n normalized_lengths = (np.array(self._lengths) - min(self._lengths)) / (\n max(self._lengths) + 1e-6)\n probabilities = _softmax(-normalized_lengths, temperature=1.0)\n return np.random.choice(self._programs, p=probabilities)\n" }, { "path": "baseline/funsearch/implementation/sampler.py", "content": "# Copyright 2023 DeepMind Technologies Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n\"\"\"Class for sampling new programs.\"\"\"\nfrom __future__ import annotations\nfrom abc import ABC, abstractmethod\n\nfrom typing import Collection, Sequence, Type\nimport numpy as np\nimport time\n\nfrom implementation import evaluator\nfrom implementation import programs_database\n\n\nclass LLM(ABC):\n \"\"\"Language model that predicts continuation of provided source code.\n\n RZ: The sampled function code must be trimmed! Especially using instruct-based LLM.\n -For example, the sampled function code (with description) is:\n ------------------------------------------------------------------------------------------------------------------\n Here is the function.\n def priority_v2(..., ...) -> Any:\n a = np.array([1, 2, 3])\n if len(a) > 2:\n return a / a.sum()\n else:\n return a / a.mean()\n This function is going to ..., and returns ...[Descriptions by LLM]\n ------------------------------------------------------------------------------------------------------------------\n -The descriptions above the function's signature, and the function's signature must be removed.\n -The above code must be trimmed as follows:\n ------------------------------------------------------------------------------------------------------------------\n a = np.array([1, 2, 3])\n if len(a) > 2:\n return a / a.sum()\n else:\n return a / a.mean()\n Here is the function. This function is going to ..., and returns ...[Descriptions by LLM]\n ------------------------------------------------------------------------------------------------------------------\n Please note that the indent must be preserved. And the additional descriptions can also be preserved,\n which will be trimmed by Evaluator.\n \"\"\"\n\n def __init__(self, samples_per_prompt: int) -> None:\n self._samples_per_prompt = samples_per_prompt\n\n def _draw_sample(self, prompt: str) -> str:\n \"\"\"Returns a predicted continuation of `prompt`.\"\"\"\n raise NotImplementedError('Must provide a language model.')\n\n @abstractmethod\n def draw_samples(self, prompt: str) -> Collection[str]:\n \"\"\"Returns multiple predicted continuations of `prompt`.\"\"\"\n return [self._draw_sample(prompt) for _ in range(self._samples_per_prompt)]\n\n\nclass Sampler:\n \"\"\"Node that samples program continuations and sends them for analysis.\n \"\"\"\n _global_samples_nums: int = 1 # RZ: this variable records the global sample nums\n\n def __init__(\n self,\n database: programs_database.ProgramsDatabase,\n evaluators: Sequence[evaluator.Evaluator],\n samples_per_prompt: int,\n max_sample_nums: int | None = None,\n llm_class: Type[LLM] = LLM\n ):\n self._samples_per_prompt = samples_per_prompt\n self._database = database\n self._evaluators = evaluators\n self._llm = llm_class(samples_per_prompt)\n self._max_sample_nums = max_sample_nums\n\n def sample(self, **kwargs):\n \"\"\"Continuously gets prompts, samples programs, sends them for analysis.\n \"\"\"\n while True:\n # stop the search process if hit global max sample nums\n if self._max_sample_nums and self.__class__._global_samples_nums >= self._max_sample_nums:\n break\n\n prompt = self._database.get_prompt()\n reset_time = time.time()\n samples = self._llm.draw_samples(prompt.code)\n sample_time = (time.time() - reset_time) / self._samples_per_prompt\n # This loop can be executed in parallel on remote evaluator machines.\n for sample in samples:\n self._global_sample_nums_plus_one() # RZ: add _global_sample_nums\n cur_global_sample_nums = self._get_global_sample_nums()\n chosen_evaluator: evaluator.Evaluator = np.random.choice(self._evaluators)\n chosen_evaluator.analyse(\n sample,\n prompt.island_id,\n prompt.version_generated,\n **kwargs,\n global_sample_nums=cur_global_sample_nums,\n sample_time=sample_time\n )\n\n def _get_global_sample_nums(self) -> int:\n return self.__class__._global_samples_nums\n\n def set_global_sample_nums(self, num):\n self.__class__._global_samples_nums = num\n\n def _global_sample_nums_plus_one(self):\n self.__class__._global_samples_nums += 1\n" }, { "path": "baseline/funsearch/llm-server/llm_server.py", "content": "import gc\nfrom argparse import ArgumentParser\nfrom threading import Thread\nfrom typing import Iterator, Optional\nimport torch\nfrom transformers import (\n AutoConfig, AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer, BitsAndBytesConfig, TextStreamer\n)\nfrom flask import Flask, request, jsonify, Response, stream_with_context\n\nfrom flask_cors import CORS\nimport json\nimport os\n\n# model_path_home = '/raid/zhichao/zhangrui/LLMs'\ndefault_model_path_path = '/raid/zhichao/zhangrui/LLMs/CodeLlama-7b-Instruct-hf'\n\n# arguments\nparser = ArgumentParser()\nparser.add_argument('--d', nargs='+', default=['1', '2', '3'])\nparser.add_argument('--quantization', default=False, action='store_true')\nparser.add_argument('--path', type=str, default=default_model_path_path)\nparser.add_argument('--host', type=str, default='127.0.0.1')\nparser.add_argument('--port', type=int, default=11011)\n\nargs = parser.parse_args()\n\n# cuda visible devices\ncuda_visible_devices = ','.join(args.d)\nos.environ['CUDA_VISIBLE_DEVICES'] = cuda_visible_devices\n\n# set quantization (do not quantization by default)\nif args.quantization:\n quantization_config = BitsAndBytesConfig(\n load_in_8bit=True,\n # load_in_4bit=True,\n # bnb_4bit_compute_dtype=torch.float16,\n # llm_int8_enable_fp32_cpu_offload=True\n )\nelse:\n quantization_config = None\n\n# CodeLlama-Python model\npretrained_model_path = args.path\nconfig = AutoConfig.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id,\n # cache_dir=None,\n)\n# config.pretraining_tp = 1\nmodel = AutoModelForCausalLM.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id=None,\n # config=config,\n quantization_config=quantization_config,\n device_map='auto',\n # cache_dir=None,\n # use_safetensors=False,\n)\n\n# tokenizer for the LLM\ntokenizer = AutoTokenizer.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n)\n\n# Flask API\napp = Flask(__name__)\nCORS(app)\n\n\n@app.route(f'/completions', methods=['POST'])\ndef completions():\n content = request.json\n prompt = content['prompt']\n prompt = [\n {'role': 'user', 'content': prompt}\n ]\n repeat_prompt = content.get('repeat_prompt', 1)\n\n # due to the limitations of the GPU devices in the server, the maximum repeat prompt have to be restricted\n max_repeat_prompt = 10\n repeat_prompt = min(max_repeat_prompt, repeat_prompt)\n\n print(f'========================================== Prompt ==========================================')\n print(f'{prompt}\\n')\n print(f'============================================================================================')\n print(f'\\n\\n')\n\n max_new_tokens = 512\n temperature = 0.3\n do_sample = True\n top_k = 30\n top_p = 0.9\n num_return_sequences = 1\n eos_token_id = 32021\n pad_token_id = 32021\n\n if 'params' in content:\n params: dict = content.get('params')\n max_new_tokens = params.get('max_new_tokens', 512)\n temperature = params.get('temperature', 0.3)\n do_sample = params.get('do_sample', True)\n top_k = params.get('top_k', 30)\n top_p = params.get('top_p', 0.9)\n num_return_sequences = params.get('num_return_sequences', 1)\n eos_token_id = params.get('eos_token_id', 32021)\n pad_token_id = params.get('pad_token_id', 32021)\n\n while True:\n inputs = tokenizer.apply_chat_template(prompt, add_generation_prompt=True, return_tensors='pt')\n inputs = torch.vstack([inputs] * repeat_prompt).to(model.device)\n\n try:\n # LLM inference\n output = model.generate(\n inputs,\n max_new_tokens=max_new_tokens,\n temperature=temperature,\n do_sample=do_sample,\n top_k=top_k,\n top_p=top_p,\n num_return_sequences=num_return_sequences,\n eos_token_id=eos_token_id,\n pad_token_id=pad_token_id\n )\n except torch.cuda.OutOfMemoryError as e:\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n # decrease repeat_prompt num\n repeat_prompt = max(repeat_prompt // 2, 1)\n continue\n\n content = []\n for i, out_ in enumerate(output):\n content.append(tokenizer.decode(output[i, len(inputs[i]):], skip_special_tokens=True))\n\n print(f'======================================== Response Content ========================================')\n print(f'{content}\\n')\n print(f'==================================================================================================')\n print(f'\\n\\n')\n\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n\n # Send back the response.\n return jsonify(\n {'content': content}\n )\n\n\nif __name__ == '__main__':\n app.run(host=args.host, port=args.port)\n" }, { "path": "baseline/funsearch/llm-server/request.py", "content": "import time\n\nimport requests\nimport json\n\nurl = 'http://127.0.0.1:11011/completions'\n\nwhile True:\n prompt = '''Complete a Python function inspired by the given functions. \nYou must generate a function that is different from the previous functions.\nYou must be creative and you can add various control flow statements. \nOnly output the Python code, no descriptions. \n\n\ndef priority_v0(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns priority with which we want to add item to each bin.\n\n Args:\n item: Size of item to be added to the bin.\n bins: Array of capacities for each bin.\n\n Return:\n Array of same size as bins with priority score of each bin.\n \"\"\"\n penalty = np.arange(len(bins), 0, -1)\n scores = bins / (bins - item) - penalty\n max_capacity_bins = np.where(bins == bins.max())[0]\n for idx in max_capacity_bins:\n scores[idx] = -np.inf\n return scores\n\n\ndef priority_v1(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Improved version of `priority_v0`.\"\"\"\n'''\n\n\n\n data = {\n 'prompt': prompt,\n 'repeat_prompt': 5,\n 'system_prompt': '',\n 'stream': False,\n 'params': {\n 'temperature': 0.5,\n 'top_k': None,\n 'top_p': None,\n 'add_special_tokens': False,\n 'skip_special_tokens': True,\n }\n }\n\n # inputs, max_new_tokens=512, do_sample=False, top_k=50, top_p=0.95, num_return_sequences=1, eos_token_id=32021\n\n headers = {'Content-Type': 'application/json'}\n\n record_time = time.time()\n response = requests.post(url, data=json.dumps(data), headers=headers)\n durations = time.time() - record_time\n\n def process_response_content(content: str) -> str:\n ret = content.split('[/INST]')[1]\n return ret\n\n if response.status_code == 200:\n print(f'Query time: {durations}')\n # print(f'Response: {response.json()}')\n content = response.json()[\"content\"]\n for c in content:\n # content = process_response_content(content)\n print(f'{c}')\n else:\n print('Failed to make the POST request.')\n\n" }, { "path": "baseline/funsearch/requiremetns.txt", "content": "# Rui Zhang 01/09/2024\n# funsearch requires the following requirements\n# Python version MUST be larger or equal than Python 3.9 !!!\n\ntransformers\nbitsandbytes\ntorch\nabsl-py\nscipy\nflask\nflask-cors\nnumba\ntensorboard\ntensorboardX\n\n" }, { "path": "docs/QuickGuide.md", "content": "# Step-by-step Guide on Applying EoH on Your Problem ?\n\n\n\nComing soon\n\n\n\n\n\n\n\n" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (max_capacity - bins) / max_capacity)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = bins - item\\n scores = capacity / np.maximum(capacity, 1)\\n scores = np.where(bins == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n full_bins = bins == np.max(bins)\\n scores = (full_bins * item) + (1 - full_bins) * remaining_capacity\\n scores[scores == np.max(scores)] = 0\\n return scores\",\n \"objective\": 0.14358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n full_bins = bins == np.max(bins)\\n scores = (full_bins * item) + (1 - full_bins) * remaining_capacity\\n return scores\",\n \"objective\": 0.76245,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n item_arr = np.full_like(bins, item)\\n non_zero_mask = bins != item_arr\\n scores = np.where(non_zero_mask, bins / item_arr, np.inf)\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1e-6)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / (bins[mask] - item + 1) * np.log(bins[mask])\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 * np.arange(len(bins)) + 2)[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 + np.arange(len(bins)))[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (2 * bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item * np.arange(1, len(bins)+1)) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / (np.maximum(1, bins[~mask] - item) + 1e-6)\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = bins[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 3 * np.arange(len(bins))\\n scores[bins == max_capacity] -= 2 * item\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n scores[i] = (3 * bins[i] - 2 * item) / (2 + i) + (bins[i] > item)\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n max_capacity = sorted_bins[-1]\\n scores = (sorted_bins - item * np.arange(1, len(sorted_bins)+1)) * (sorted_bins != max_capacity)\\n return scores\",\n \"objective\": 0.04296,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 3 * np.arange(len(bins)) + (bins == max_capacity) * item\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask]))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1e-6)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / (bins[mask] - item + 1) * np.log(bins[mask])\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 * np.arange(len(bins)) + 2)[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = bins[i] / (np.maximum(1, bins[i] - item) + 1e-6) * (i+1)\\n \\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 + np.arange(len(bins)))[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (2 * bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item * np.arange(1, len(bins)+1)) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mask = bins != np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[mask] = bins[mask] / (np.maximum(1, bins[mask] - item) + 1e-6)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = bins[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 3 * np.arange(len(bins))\\n scores[bins == max_capacity] -= 2 * item\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n scores[i] = (3 * bins[i] - 2 * item) / (2 + i) + (bins[i] > item)\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask])) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1e-6) + (2 * bins[mask] > 3 * item).astype(int)\\n scores[~mask] = -1\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask]))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item))\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1e-6)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / (bins[mask] - item + 1) * np.log(bins[mask])\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == np.max(bins), -1, np.square(item / bins))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = ((bins[mask] + item) / (bins[mask] - item + 1)) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.empty_like(bins)\\n \\n diff = bins - item\\n diff[diff <= 0] = 1\\n scores = bins / diff * (np.arange(len(bins)) + 1)\\n scores[bins == max_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 * np.arange(len(bins)) + 2)[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = bins[i] / (np.maximum(1, bins[i] - item) + 1e-6) * (i+1)\\n \\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 + np.arange(len(bins)))[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (2 * bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n \\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask])) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (bins[mask] - item + 1e-6) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / (bins[mask] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask]))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item))\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1e-6)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / (bins[mask] - item + 1) * np.log(bins[mask])\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Exclude bins with maximum capacity\\n mask = bins != max_capacity\\n \\n # Calculate the scores for each bin\\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == np.max(bins), -1, np.square(item / bins))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = ((bins[mask] + item) / (bins[mask] - item + 1)) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.empty_like(bins)\\n \\n diff = bins - item\\n diff[diff <= 0] = 1\\n scores = bins / diff * (np.arange(len(bins)) + 1)\\n scores[bins == max_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 * np.arange(len(bins)) + 2)[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = bins[i] / (np.maximum(1, bins[i] - item) + 1e-6) * (i+1)\\n \\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + np.log(bins[mask]) * bins[mask]\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask])) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = ((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask])\\n \\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n\\n scores[mask] = item / (bins[mask] - item + 1e-6) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / (bins[mask] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask]))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item))\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1e-6)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / (bins[mask] - item + 1) * np.log(bins[mask])\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == np.max(bins), -1, np.square(item / bins))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (item / (bins[mask] - item + 1)) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.empty_like(bins)\\n \\n diff = bins - item\\n diff[diff <= 0] = 1\\n scores = bins / diff * (np.arange(len(bins)) + 1)\\n scores[bins == max_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n # Calculate the modified scores based on the given formula\\n scores[mask] = ((item / (bins[mask] - item + 1)) ** 2) + (item * bins[mask]) / np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + np.log(bins[mask]) * bins[mask]\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask])) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = ((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask])\\n \\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask])) / (1 + np.sqrt(bins[mask]))\\n \\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n\\n scores[mask] = item / (bins[mask] - item + 1e-6) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / (bins[mask] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask]))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item))\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1e-6)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (bins[mask] - item + 1) * np.log(bins[mask])\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (2 * item + 1) / (bins[mask] - item + 1)\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + (item * bins[mask]) / np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + np.log(bins[mask]) * bins[mask]\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask])) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + np.log(bins[mask]) * bins[mask] + np.sqrt(item * bins[mask])\\n \\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = ((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask])\\n \\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask])) / (1 + np.sqrt(bins[mask]))\\n \\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1e-6) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / (bins[mask] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask]))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n ones = np.ones_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = np.sqrt(item) / (bins[mask] - item + ones[mask])\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item))\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1e-6)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n # Calculate the first part of the score\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n\\n # Calculate the second part of the score\\n scores += (2 * bins > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + (item * bins[mask]) / np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.sqrt((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item / (bins[mask] - item + 1)) ** 2) + (np.log(bins[mask]) * bins[mask])\\n\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = np.sqrt(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask])) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + np.log(bins[mask]) * bins[mask] + np.sqrt(item * bins[mask])\\n \\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = ((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Adjust scores based on remaining capacity\\n scores = scores + (2 * bins > 3 * item).astype(int)\\n \\n # Set scores of bins with maximum capacity to zero\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = ((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask])\\n \\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask])) / (1 + np.sqrt(bins[mask]))\\n \\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n scores = np.zeros(n)\\n \\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n \\n bin_item_diff = bins[mask] - item + 1\\n scores[mask] = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n # Calculate the first part of the score\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n\\n # Calculate the second part of the score\\n scores += (2 * bins > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item / (bins[mask] - item + 1)) ** 2) + (item * bins[mask] / np.log(bins[mask])) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + (item * bins[mask]) / np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.sqrt((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item / (bins[mask] - item + 1)) ** 2) + (np.log(bins[mask]) * bins[mask])\\n\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = np.sqrt(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / ((bins[mask] - item + 1) * np.log(bins[mask])) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / (bins[mask] - item + 1)) ** 2 + np.log(bins[mask]) * bins[mask] + np.sqrt(item * bins[mask])\\n \\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int) - (bins[mask] % item == 0).astype(int)\\n\\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = ((item ** 2) / (bins[mask] - item + 1)) + (np.log(bins[mask]) * bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Adjust scores based on remaining capacity\\n scores = scores + (2 * bins > 3 * item).astype(int)\\n \\n # Set scores of bins with maximum capacity to zero\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1)**2)) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.square(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item)) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n # Calculate the first part of the score\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n\\n # Calculate the second part of the score\\n scores += (2 * bins > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item / (bins[mask] - item + 1)) ** 2) + (item * bins[mask] / np.log(bins[mask])) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) ** 2)) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.power(item / (bins[mask] - item + 1), 2) + item * bins[mask] / np.log(bins[mask]) + np.sqrt(bins[mask]) + (bins[mask] > 3 * item * 2).astype(int)\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_diff = bins - item + 1\\n \\n scores = (item / (bin_diff * (1 + np.log(bin_diff)))) ** 2 + np.sqrt(bins)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item**2) / ((bins[mask] - item + 1)**2 * (1 + np.log(bins[mask] - item + 1)**2))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.sqrt((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.log(bins[mask]) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item / (bins[mask] - item + 1)) ** 2) + (np.log(bins[mask]) * bins[mask])\\n\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.sqrt(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (max_capacity - bins) / max_capacity)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - bin_capacity + item) / max_capacity\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(num_bins, 0, -1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = (normalized_capacity ** num_bins) * weights\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / max(1, bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, (max_capacity - bins) / max_capacity)\\n scores = scores * (bins > item)\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n scores[bins == item] = -1\\n scores[bins > item] = item / bins[bins > item]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = bins - item\\n scores = capacity / np.maximum(capacity, 1)\\n scores = np.where(bins == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = np.subtract(bins, item)\\n scores = np.divide(capacity, np.maximum(capacity, 1))\\n scores = np.where(capacity == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = (max_capacity - bins[bins != max_capacity]) / max_capacity\\n scores *= bins > item\\n \\n scores[scores == np.max(scores)] = 0\\n \\n return scores\",\n \"objective\": 0.05936,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1)))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.square(item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item)) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n # Calculate the first part of the score\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))\\n\\n # Calculate the second part of the score\\n scores += (2 * bins > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item / (bins[mask] - item + 1)) ** 2) + (item * bins[mask] / np.log(bins[mask])) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) ** 2)) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.power(item / (bins[mask] - item + 1), 2) + item * bins[mask] / np.log(bins[mask]) + np.sqrt(bins[mask]) + (bins[mask] > 3 * item * 2).astype(int)\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n \\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + (2 * np.log(bins[mask]) / np.log(max_capacity))\\n \\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_diff = bins - item + 1\\n \\n scores = (item / (bin_diff * (1 + np.log(bin_diff)))) ** 2 + np.sqrt(bins)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = ((item**2) / ((bins[mask] - item + 1)**2 * (1 + np.log(bins[mask] - item + 1)**2))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.sqrt((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.exp(bins[mask] - item)) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n first_part = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))) ** 2\\n \\n # Calculate the second part of the score\\n second_part = np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins)\\n \\n # Calculate the final score\\n scores = np.where(bins != max_capacity, first_part + second_part, scores)\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item)) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) ** 2)) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / (bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = np.power(item / (bins[mask] - item + 1), 2) + item * bins[mask] / np.log(bins[mask]) + np.sqrt(bins[mask]) + (bins[mask] > 3 * item * 2).astype(int)\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_diff = bins - item + 1\\n \\n scores = (item / (bin_diff * (1 + np.log(bin_diff)))) ** 2 + np.sqrt(bins)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + np.logical_and(2 * bins[mask] > 3 * item, rest_capacity > 0).astype(int)\\n \\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n indices = np.arange(len(bins))\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n # Set the score of bins with maximum capacity to zero\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item)) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)**2)) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n \\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / (bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0)).astype(int)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0))\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item)) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n # Calculate the scores using a different formula\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (3 * bins[mask] > 2 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / (bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0)).astype(int)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0))\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item)) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (3 * bins[mask] > 2 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / (bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = (item / (rest_capacity * (1 + np.log(rest_capacity))**2)) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n \\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0))\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + np.ceil((2 * bins[mask]) / (3 * item))\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (3 * bins[mask] > 2 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / (bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2 * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_26.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n bin_item_diff = bins - item + 1\\n \\n scores = item / (bin_item_diff * (1 + np.log(bin_item_diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n rest_capacity = bins - item\\n scores = np.divide(item, np.multiply(rest_capacity, np.log1p(rest_capacity)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = (item / (rest_capacity * (1 + np.log(rest_capacity))**2)) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0))\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + np.ceil((2 * bins[mask]) / (3 * item))\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (3 * bins[mask] > 2 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_27.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0))\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = (item / (diff * (1 + np.log(diff)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (3 * bins[mask] > 2 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_28.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0))\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = (item / (diff * (1 + np.log(diff)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (3 * bins[mask] > 2 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_29.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n rest_capacity = bins - item\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins[mask]) + ((2 * bins[mask] > 3 * item) & (rest_capacity > 0))\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = (item / (diff * (1 + np.log(diff)))) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2*np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask]) + bins[mask] // item\\n\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (3 * bins[mask] > 2 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1)))**2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.empty_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = -1\\n scores[~mask] = (item / bins[~mask])**2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(num_bins, 0, -1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = (normalized_capacity ** num_bins) * weights\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / max(1, bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / max_capacity\\n scores[bins == max_capacity] = 0\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (bins[i] - item) / (1 + i)\\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n scores[bins == item] = -1\\n scores[bins > item] = item / bins[bins > item]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = bins - item\\n scores = capacity / np.maximum(capacity, 1)\\n scores = np.where(bins == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = np.subtract(bins, item)\\n scores = np.divide(capacity, np.maximum(capacity, 1))\\n scores = np.where(capacity == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = (max_capacity - bins[bins != max_capacity]) / max_capacity\\n scores *= bins > item\\n \\n scores[scores == np.max(scores)] = 0\\n \\n return scores\",\n \"objective\": 0.05936,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.linspace(1, num_bins, num_bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n scores[bins == np.max(bins)] = 0\\n scores = scores * (bins > item)\\n return scores\",\n \"objective\": 0.06459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_30.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n\\n # Add a modified third part of the score\\n scores += np.exp(-(bins - item + 1)) / (1 + np.exp(-(bins - item + 1)))\\n \\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n rest_capacity = bins - item + 1\\n \\n scores = item / ((rest_capacity) * (1 + np.log1p(rest_capacity)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n rest_capacity = bins - item\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n rest_capacity = bins - item + 1\\n \\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = np.exp(item / (rest_capacity * np.log1p(rest_capacity)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + 2 * np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_31.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n\\n # Add a modified third part of the score\\n scores += np.exp(-(bins - item + 1)) / (1 + np.exp(-(bins - item + 1)))\\n \\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / ((rest_capacity) * (1 + np.log1p(rest_capacity)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n rest_capacity = bins - item\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (rest_capacity > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.exp(item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (diff > 0))\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_32.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n\\n # Add a modified third part of the score\\n scores += np.exp(-(bins - item + 1)) / (1 + np.exp(-(bins - item + 1)))\\n \\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = item / (diff**2 * np.log(diff + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n rest_capacity = bins[mask] - item + 1\\n\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n\\n scores = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins) + ((2 * bins > 3 * item) & (diff > 0))\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.exp(item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (diff > 0))\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item / ((bins - item + 1) * (1 + np.log(bins - item + 1))))**2 + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_33.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n\\n # Add a modified third part of the score\\n scores += np.exp(-(bins - item + 1)) / (1 + np.exp(-(bins - item + 1)))\\n \\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = item / (diff**2 * np.log(diff + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = item / ((diff * np.log1p(diff))**2) + np.sqrt(bins) + ((2 * bins > 3 * item) & (diff > 0))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n\\n scores = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) ** 2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.exp(item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (diff > 0))\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item + 1\\n sqrt_diff = np.sqrt(diff + 1)\\n scores = item / (diff**2 * np.log(diff + 1)) + sqrt_diff + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_34.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n\\n # Calculate the third part of the score\\n scores += np.exp(-(bins - item + 1)) / (1 + np.exp(-(bins - item + 1)))\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = item / (diff**2 * np.log(diff + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = item / (diff**2 * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.exp(item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (diff > 0))\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item + 1\\n sqrt_diff = np.sqrt(diff + 1)\\n scores = item / (diff**2 * np.log(diff + 1)) + sqrt_diff + (2 * bins > 3 * item).astype(int)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + np.ceil(2 * bins[mask] / (3 * item))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_35.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n\\n # Calculate the third part of the score\\n scores += np.exp(-(bins - item + 1)) / (1 + np.exp(-(bins - item + 1)))\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item**3) / (bins[mask]**3 - item**3 + 1) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff**2 * np.log1p(diff)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = item / (diff**2 * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins) + (2 * bins > 3 * item)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1)**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (bins[mask] - item + 1) ** 2 + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item + 1\\n \\n scores = np.exp(item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + ((2 * bins > 3 * item) & (diff > 0))\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_36.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**4) / (bins**4 - item**4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1))) * (1 + np.exp(-(bins - item + 1)))\\n\\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item**3) / (bins[mask]**3 - item**3 + 1) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n scores = np.where(bins != max_capacity, (item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = item / (diff**2 * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_37.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**4) / (bins**4 - item**4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1))) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item**3) / (bins[mask]**3 - item**3 + 1) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n scores = np.where(bins != max_capacity, (item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item + 1\\n\\n scores = item / (rest_capacity * np.log1p(rest_capacity)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_38.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**4) / (bins**4 - item**4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (item**3) / (bins[mask]**3 - item**3 + 1) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n scores = np.where(bins != max_capacity, (item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = item / ((bins[mask] - item + 1) * (1 + np.log(bins[mask] - item + 1))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item).astype(int) + np.log(bins[mask])\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_39.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**4) / (bins**4 - item**4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) ** 2) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n scores = np.where(bins != max_capacity, (item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, -1)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(num_bins, 0, -1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = (normalized_capacity ** num_bins) * weights\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / (max(1, bins[i] - item) + 1e-6)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / max(1, bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / max_capacity\\n scores[bins == max_capacity] = 0\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n scores[bins == item] = -1\\n scores[bins > item] = item / bins[bins > item]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = bins - item\\n scores = capacity / np.maximum(capacity, 1)\\n scores = np.where(bins == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = np.subtract(bins, item)\\n scores = np.divide(capacity, np.maximum(capacity, 1))\\n scores = np.where(capacity == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n\\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = (max_capacity - bins[bins != max_capacity]) / max_capacity\\n scores *= bins > item\\n\\n scores[scores == np.max(scores)] = 0\\n\\n return scores\",\n \"objective\": 0.05936,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_40.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**4) / (bins**4 - item**4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n scores = np.where(bins != max_capacity, (item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2)) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_41.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n scores = np.where(bins != max_capacity, (item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2)) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n diff = bins[mask] - item + 1\\n scores[mask] = item / (diff**2 * (1 + np.log(diff))) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_42.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item + 1\\n scores = np.where(bins != max_capacity, item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**2) / (bins**2 - item**2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n scores = np.where(bins != max_capacity, (item / (diff * np.log1p(diff)**2)) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2)) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n\\n rest_capacity = bins[mask] - item + 1\\n scores[mask] = item / (rest_capacity * (1 + np.log(rest_capacity))**2) + np.sqrt(bins[mask]) + (2 * bins[mask] > 3 * item)\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_43.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n # Calculate the scores for each bin\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n # Disable the bins with maximum capacity\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (item > 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 2 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2)) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_44.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n # Calculate the scores for each bin\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n # Disable the bins with maximum capacity\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (item > 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 2 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2)) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + np.log(bins + 1) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_45.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 3) / (bins ** 3 - item ** 3 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (item > 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 2 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(item / (np.power(bins - item + 1, 2)) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int))\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_46.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (item > 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + ((3 * bins) > (2 * item)).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = item / ((bins - item + 1) * np.log(bins - item + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item / (bins - item + 1)**2) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_47.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((item ** 3) / (bins ** 3 - item ** 3 + 1)) + (np.sqrt(bins)) + ((2 * bins) > (3 * item)).astype(int) + (2 * np.log(bins + 1))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (item > 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + ((3 * bins) > (2 * item)).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item / (bins - item + 1)**2) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_48.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((item ** 3) / (bins ** 3 - item ** 3 + 1)) + (np.sqrt(bins)) + ((2 * bins) > (3 * item)).astype(int) + (2 * np.log(bins + 1))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = ((item ** 2) / (bins ** 2 - item ** 2 + 1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = np.exp(item / (np.power(bins - item + 1, 2))) + np.sqrt(bins) + np.logical_and(2 * bins > 3 * item, bins > 0).astype(int) + (item > 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + ((3 * bins) > (2 * item)).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item / (bins - item + 1)**2) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_49.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((item ** 3) / (bins ** 3 - item ** 3 + 1)) + (np.sqrt(bins)) + ((2 * bins) > (3 * item)).astype(int) + (2 * np.log(bins + 1))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + 2 * np.log(bins + 1)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + ((bins % item) == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((item ** 3) / (bins ** 3 - item ** 3 + 1)) + (2 * np.sqrt(bins)) + ((2 * bins) > (3 * item)).astype(int) + (3 * np.log(bins + 1))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + ((3 * bins) > (2 * item)).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item / (bins - item + 1)**2) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / (bins[i] - item + 1e-6)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, -1)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item * (np.arange(len(bins)) + 1)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / (np.maximum(1, bins[~mask] - item) + 1e-6)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / max(1, bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n denom = bins - item\\n denom[denom == 0] = 1\\n \\n scores[mask] = denom[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / max_capacity\\n scores[bins == max_capacity] = 0\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n scores[bins == item] = -1\\n scores[bins > item] = item / bins[bins > item]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = bins - item\\n scores = np.where(capacity == bins.max() - item, 0, capacity / np.maximum(capacity, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = np.subtract(bins, item)\\n scores = np.divide(capacity, np.maximum(capacity, 1))\\n scores = np.where(capacity == bins.max(), 0, scores)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_50.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log1p(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 4) / (bins ** 4 - item ** 4 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins) + (bins % item == 0).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((item ** 3) / (bins ** 3 - item ** 3 + 1)) + (np.sqrt(bins)) + ((2 * bins) > (3 * item)).astype(int) + (2 * np.log(bins + 1))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**5) / (bins**5 - item**5 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 2)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + ((3 * bins) > (2 * item)).astype(int) + np.log(bins + 2)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the first part of the score\\n scores = item / ((bins - item + 1) * (1 + np.log(bins - item + 1)))\\n \\n # Calculate the second part of the score\\n scores += 2 * (bins > 3 * item)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = (item**3) / (bins**3 - item**3 + 1) + np.sqrt(bins) + (3 * bins >= 2 * item).astype(int) + np.log(bins**2 + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item + 1\\n scores = np.where(bins != np.max(bins), item / (diff * np.log1p(diff)**2) + np.sqrt(bins) + (2 * bins > 3 * item), 0)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int) + np.log(bins + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + 2 * np.sqrt(bins) + 2 * np.minimum(1, bins > item * 0.75) + 3 * np.log(bins + 1)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item**2) / ((bins**2 - item**2 + 1) * np.log(bins+1)) + np.sqrt(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = item**3 / (bins**3 - item**3 + 1) + np.sqrt(bins) + ((3 * bins) > (2 * item)).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 2) / (bins ** 2 - item ** 2 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item / (bins - item + 1)**2) + np.sqrt(bins) + np.log1p(bins) + (2 * bins > 3 * item).astype(int)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = (item ** 3) / (bins ** 3 - item ** 3 + 1) + np.sqrt(bins) + (3 * bins > 4 * item).astype(int) + 3 * np.log(bins + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / (bins[i] - item + 1e-6)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, -1)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item * (np.arange(len(bins)) + 1)) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / (np.maximum(1, bins[~mask] - item) + 1e-6)\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / max(1, bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n denom = bins - item\\n denom[denom == 0] = 1\\n \\n scores[mask] = denom[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[:] = (2 * bins - item) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / max_capacity\\n scores[bins == max_capacity] = 0\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - item) / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n mask = bins > item\\n scores[mask] = item / bins[mask]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = bins - item\\n scores = np.where(capacity == bins.max() - item, 0, capacity / np.maximum(capacity, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = item / (bins[i] - item + 1e-6)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item * (np.arange(len(bins)) + 1)) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / (np.maximum(1, bins[~mask] - item) + 1e-6)\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = bins[bins != max_capacity] / np.maximum(1, bins[bins != max_capacity] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n denom = bins - item\\n denom[denom == 0] = 1\\n \\n scores[mask] = denom[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[:] = (2 * bins - item) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = np.where(bins[mask] - item > 0, bins[mask] / (bins[mask] - item), 0)\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, item / bins)\\n scores[bins - item <= 0] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - np.arange(len(bins)), 0)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - item) / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n mask = bins > item\\n scores[mask] = item / bins[mask]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n scores[i] = item / (bins[i] - item + 1e-6)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (2 * bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item * (np.arange(len(bins)) + 1)) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / (np.maximum(1, bins[~mask] - item) + 1e-6)\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = bins[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n denom = bins - item\\n denom[denom == 0] = 1\\n \\n scores[mask] = denom[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[:] = (3 * bins - item) / (2 + np.arange(len(bins))) + (bins > item).astype(int)\\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[:] = (2 * bins - item) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = np.where(bins[mask] - item > 0, bins[mask] / (bins[mask] - item), 0)\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, item / bins)\\n scores[bins - item <= 0] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - np.arange(len(bins))**2 - item\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04829,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n scores[i] = item / (bins[i] - item + 1e-6)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, (item / bins)**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (item / bins[mask]) ** 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = np.power(normalized_capacity, num_bins) * np.arange(num_bins, 0, -1)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 + np.arange(len(bins)))[mask] + (2 * bins[mask] > 3 * item).astype(int)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (2 * bins[mask] - item) / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item * np.arange(1, len(bins)+1)) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(item, bins) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / (np.maximum(1, bins[~mask] - item) + 1e-6)\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n scores[mask] = bins[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (3 * bins[mask] - 2 * item) / (2 + np.arange(len(bins)))[mask] + (bins[mask] > item).astype(int)\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 3 * np.arange(len(bins)) + (bins == max_capacity) * item\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - 2 * np.arange(len(bins))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n \\n denom = bins - item\\n denom[denom == 0] = 1\\n \\n scores[mask] = denom[mask] / (1 + np.arange(len(bins)))[mask]\\n \\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[:] = (3 * bins - item) / (2 + np.arange(len(bins))) + (bins > item).astype(int)\\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[:] = (2 * bins - item) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * (1 - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = (bins / (bins - item)).clip(0, 1)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_cap:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] / max(1, bins[i] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_cap = np.max(bins)\\n for i, bin_size in enumerate(bins):\\n if bin_size == max_cap:\\n scores[i] = -np.inf\\n elif bin_size > item:\\n scores[i] = item / bin_size\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item]\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = (bins // item) - (bins == max_cap)\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.10333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - item/bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = 0\\n scores[np.logical_not(unused_bins)] = (1 - item / (bins[np.logical_not(unused_bins)] - item)) * (bins[np.logical_not(unused_bins)] != max_capacity)\\n return scores\",\n \"objective\": 0.25174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (item - bins) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / np.maximum((bins[mask] - item), 1)\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = 1 / (bins[mask] - item)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / diff[diff > 0]\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = (max_cap - bins[mask] + 1) / (bins[mask] - item + 1)\\n \\n scores[bins == max_cap] = 0\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = item / (item + bins[mask] - max_cap)\\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n\\n scores = np.zeros(num_bins)\\n mask = (bins != max_cap) & (bins != min_cap)\\n scores[mask] = 1 - ((item - bins[mask]) / (item - min_cap))\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = (max_cap - item) / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item + 1)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n num_bins = len(bins)\\n \\n scores = np.zeros(num_bins)\\n \\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n \\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = item / (bins[mask] - item + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / diff[diff > 0]\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = (max_cap - bins[mask] + 1) / (bins[mask] - item + 1)\\n \\n scores[bins == max_cap] = 0\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n # Remove bins with maximum capacity from consideration\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n\\n # Assign a higher score to bins with rest capacity equal to item size\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n num_bins = len(bins)\\n \\n scores = np.zeros(num_bins)\\n \\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n \\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins > item\\n scores[mask] = item / (bins[mask] - item + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / diff[diff > 0]\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = item / (bins[mask] - item + 1)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n num_bins = len(bins)\\n\\n scores = np.zeros(num_bins)\\n\\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins > item\\n scores[mask] = item / (bins[mask] - item + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = (item + 1) / (bins[mask] - item + 1)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04699,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = np.log(item) / (diff_without_max_capacity + 0.001)\\n \\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n num_bins = len(bins)\\n\\n scores = np.zeros(num_bins)\\n\\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins > item\\n scores[mask] = item / (bins[mask] - item + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = (item + 1) / (bins[mask] - item + 1)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04699,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n\\n scores[bins_without_max_capacity] = np.log(item) / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n num_bins = len(bins)\\n\\n scores = np.zeros(num_bins)\\n\\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n\\n scores = np.zeros_like(bins)\\n mask = (bins != max_capacity) & (bins != min_capacity)\\n \\n scores[mask] = item / (bins[mask] - item)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins > item\\n scores[mask] = item / (bins[mask] - item + 1)\\n\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores based on the difference between rest capacity and item size\\n diff = rest_capacity / (item + 0.001)\\n scores[rest_capacity > 0] = diff[rest_capacity > 0]\\n \\n # Set scores to 0 if the rest capacity equals the maximum capacity\\n scores[bins == max_capacity] = 0\\n \\n # Set scores to item size if the rest capacity equals the item size\\n scores[bins == item] = item\\n \\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n\\n scores[bins_without_max_capacity] = np.log(item) / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n scores[bins < max_capacity] = item / bins[bins < max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n num_bins = len(bins)\\n\\n scores = np.zeros(num_bins)\\n\\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n\\n scores = np.zeros_like(bins)\\n\\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n \\n diff = rest_capacity / (item + 0.001)\\n scores[rest_capacity > 0] = diff[rest_capacity > 0]\\n \\n scores[bins == max_capacity] = 0\\n \\n scores[bins == item] = item\\n \\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n\\n scores[bins_without_max_capacity] = np.log(item) / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n diff = bins - item\\n\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n\\n # Calculate scores based on the difference between rest capacity and item size\\n diff = rest_capacity / (item + 0.001)\\n scores = np.where(rest_capacity > 0, diff, scores)\\n\\n # Set scores to 0 if the rest capacity equals the maximum capacity\\n scores = np.where(bins == max_capacity, 0, scores)\\n\\n # Set scores to item size if the rest capacity equals the item size\\n scores = np.where(bins == item, item, scores)\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.maximum((bins[mask] - item), 1) + 0.001)\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n scores[bins < max_capacity] = item / bins[bins < max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n num_bins = len(bins)\\n\\n scores = np.zeros(num_bins)\\n\\n mask = (bins != max_capacity) & (bins != min_capacity)\\n scores[mask] = item / (bins[mask] - item)\\n\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n\\n diff = rest_capacity / (item + 0.001)\\n scores[rest_capacity > 0] = diff[rest_capacity > 0]\\n\\n scores[bins == max_capacity] = 0\\n\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item / (diff[used_bins] + 1)) + 0.001\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n diff = bins - item\\n\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = item / (diff[diff > 0] + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[bins == item] = item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.maximum((bins[mask] - item), 1) + 0.001)\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (bins != bins.max()) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n scores[bins < max_capacity] = item / bins[bins < max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n\\n diff = rest_capacity / (item + 0.001)\\n scores = np.where(rest_capacity > 0, diff, scores)\\n\\n mask = (rest_capacity != max_capacity)\\n scores[mask] = np.minimum(1, item / (rest_capacity[mask] + 0.001))\\n\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n\\n diff = rest_capacity / (item + 0.001)\\n scores[rest_capacity > 0] = diff[rest_capacity > 0]\\n\\n scores[bins == max_capacity] = 0\\n\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * np.exp(-diff[diff == item] / item)\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item / (diff[used_bins] + 1)) + 0.001\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = item / np.maximum((bins[mask] - item) + 0.001, 1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.maximum((bins[mask] - item), 1) + 0.001)\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (bins != bins.max()) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n scores[bins < max_capacity] = item / bins[bins < max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n \\n mask = (bins == max_capacity) | (bins == item)\\n scores[mask] = 0\\n \\n mask = (bins != max_capacity) & (bins != item)\\n scores[mask] = np.minimum(1, item / (rest_capacity[mask] + 0.001))\\n\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n unused_bins = (bins == max_capacity)\\n scores[~unused_bins] = item / bins[~unused_bins]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = (bins / (bins - item)).clip(0, 1)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n for i, b in enumerate(bins):\\n if b == max_cap:\\n scores[i] = 0\\n else:\\n scores[i] = b / max(1, b - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = -np.inf\\n elif bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = (item - min_cap) / (item - bins[i])\\n \\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_cap = np.max(bins)\\n for i, bin_size in enumerate(bins):\\n if bin_size == max_cap:\\n scores[i] = -np.inf\\n elif bin_size > item:\\n scores[i] = item / bin_size\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = -np.inf\\n elif bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = -((item - bins[i])/(item - min_cap))\\n \\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_cap] = 0\\n scores[bins != max_cap] = bins[bins != max_cap] / (bins[bins != max_cap] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_capacity = np.max(bins)\\n capacities = np.where(bins == max_bin_capacity, 0, bins - item)\\n scores = np.where(capacities < item, 0, capacities)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n \\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (max_capacity - bins[i]) / (bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.06681,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_size in enumerate(bins):\\n if bin_size == max_cap:\\n scores[i] = 0\\n elif bin_size == min_cap:\\n scores[i] = -np.inf\\n else:\\n scores[i] = (bin_size - item) / (bin_size - min_cap)\\n \\n return scores\",\n \"objective\": 0.06882,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n valid_bins = bins[bins != item]\\n scores = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = (bins // item) - (bins == max_cap)\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.10333,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n\\n diff = rest_capacity / (item + 0.001)\\n\\n scores[rest_capacity > 0] = diff[rest_capacity > 0]\\n scores[max_capacity == bins] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * np.exp(-diff[diff == item] / item)\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item / (diff[used_bins] + 1)) + 0.001\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.sqrt(item) / (bins[used_bins] - item + 0.001)\\n scores[bins == item] = item * np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1) + np.log(item + 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / np.maximum((bins[mask] - item) + 0.001, 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n bins_without_max_capacity = np.where(bins != max_capacity)\\n diff_without_max_capacity = diff[bins_without_max_capacity]\\n scores[bins_without_max_capacity] = item / (diff_without_max_capacity + 0.001)\\n scores[diff == item] = item\\n scores[bins == max_capacity] = 0\\n scores[bins > item] = 1 / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = item / (np.maximum((bins[mask] - item), 1) + 0.001)\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (bins != bins.max()) * (item / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n scores[bins < max_capacity] = item / bins[bins < max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n\\n diff = rest_capacity / (item + 0.001)\\n\\n scores[rest_capacity > 0] = diff[rest_capacity > 0]\\n scores[max_capacity == bins] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n \\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(diff[used_bins]) + 1\\n \\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * np.exp(-diff[diff == item] / item)\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item / (diff[used_bins] + 1)) + 0.001\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = (item / (bins[used_bins] - item + 0.001)) + np.log((bins[used_bins] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1) + np.log(item + 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (np.maximum(diff[used_bins], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n \\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1)*np.exp(-np.abs(diff[used_bins])) + item\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / np.maximum((bins[mask] - item) + 0.001, 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = np.log(item) / (diff + 0.001)\\n\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = 0\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.cbrt(item) / ((bins[used_bins] - item + 0.001)**2)\\n scores[bins == item] = (item**2) * np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[max_capacity == bins] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n diff = bins - item\\n \\n scores[mask] = (item / (diff[mask] + 0.001)) + np.log((diff[mask] + 1))\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item / (diff[used_bins] + 1)) + 0.001\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item + 1) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = (item / (bins[used_bins] - item + 0.001)) + np.log((bins[used_bins] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1) + np.log(item + 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (np.maximum(diff[used_bins], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / np.maximum((bins[mask] - item) + 0.001, 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = np.log(item) / (diff + 0.001)\\n\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = 0\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n diff = bins - item\\n \\n scores[mask] = (item / (diff[mask] + 0.001)) + np.log((diff[mask] + 1))\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item / (diff[used_bins] + 1)) + 0.001\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = (item / (bins[used_bins] - item + 0.001)) + np.log((bins[used_bins] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1) + np.log(item + 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item) + 0.001, 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (bins[used_bins] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = np.log(item) / (diff + 0.001)\\n\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = 0\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item), 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001) + np.log((diff[mask] + 1))\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = np.where(bins != max_capacity)\\n\\n scores[used_bins] = (item / (bins[used_bins] - item + 0.001)) + np.log((bins[used_bins] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item) + 0.001, 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (bins[used_bins] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = np.log(item) / (diff + 0.001)\\n\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = 0\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001) + np.log((diff[mask] + 1))\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (item / (bins[used_bins] - item + 0.001)) + np.log((bins[used_bins] - item + 1))\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item) + 0.001, 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (bins[used_bins] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = np.log(item) / (diff + 0.001)\\n\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = 0\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_26.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001) + np.log((diff[mask] + 1))\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n\\n scores[used_bins] = item / (diff + 0.001) + np.log(diff + 1)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n diff = bins - item\\n scores[mask] = item / np.maximum(diff[mask], 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item) + 0.001, 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = np.log(item) / (diff + 0.001)\\n\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = 0\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_27.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001) + np.log((diff[mask] + 1))\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = bins != max_capacity\\n\\n scores[mask] = (item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n\\n scores[used_bins] = item / (diff + 0.001) + np.log(diff + 1)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = (item + 1) / (diff + 0.001)\\n\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 0.001), 0)\\n scores[(bins == max_capacity) | (bins == item)] = 0\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item) + 0.001, 1)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores = np.log(item) / (diff + 0.001)\\n scores[bins == max_capacity] = 0\\n scores[diff == item] = 0\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_28.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001) + np.log((diff[mask] + 1))\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = 2 * item - bins[used_bins] + 1\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = bins != max_capacity\\n\\n scores[mask] = (item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores = np.log(item) / (diff + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n \\n scores[used_bins] = item / (np.sqrt(diff) + 1) + np.log(diff + 1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item) + 0.001, 1)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores = np.log(item) / (diff + 0.001)\\n scores[bins == max_capacity] = np.min(scores) - 1\\n scores[diff == item] = np.min(scores) - 1\\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_29.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n rest_capacity = bins - item\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (rest_capacity[used_bins] + 1) / (item + 0.001)\\n scores[(item == bins) | (bins == max_capacity)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] = -1\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = item - np.abs(bins[used_bins] - item) + 1\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001) + np.log(diff[mask] + 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item / (diff[used_bins] + 1)\\n\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins < max_capacity, 2 * item - bins + 1, 0)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = bins != max_capacity\\n\\n scores[mask] = (item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores = np.log(item) / (diff + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item - bins[used_bins] + 1) / (1 + bins[used_bins] - item)\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / np.maximum((bins[bins != max_capacity] - item) + 0.001, 1)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item) / (bins[used_bins] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.full_like(bins, -np.inf)\\n max_cap = np.max(bins)\\n idx = np.where(bins != max_cap)\\n scores[idx] = np.minimum(1, item / bins[idx])\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = (bins / (bins - item)).clip(0, 1)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = -np.inf\\n elif bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = (item - min_cap) / (item - bins[i])\\n \\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.where(bins == max_cap, -np.inf, np.where(bins > item, item / bins, 0))\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = 0\\n elif bins[i] == min_cap:\\n scores[i] = 1\\n else:\\n scores[i] = 1 - ((item - bins[i])/(item - min_cap))\\n \\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.where(full_bins, 0, rest_capacity / np.maximum(rest_capacity, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = -np.inf\\n elif bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = np.exp((item - min_cap) / (item - bins[i]))\\n \\n return scores\",\n \"objective\": 0.05644,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_capacity = np.max(bins)\\n capacities = np.where(bins == max_bin_capacity, 0, bins - item)\\n scores = np.where(capacities < item, 0, capacities)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n \\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (max_capacity - bins[i]) / (bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.06681,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_size in enumerate(bins):\\n if bin_size == max_cap:\\n scores[i] = 0\\n elif bin_size == min_cap:\\n scores[i] = -np.inf\\n else:\\n scores[i] = (bin_size - item) / (bin_size - min_cap)\\n \\n return scores\",\n \"objective\": 0.06882,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_30.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[(item == bins) | (bins == max_capacity)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = item - abs(bins[i] - item) + 1\\n \\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001) + np.log(diff[mask] + 1)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = item / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = bins != max_capacity\\n scores[mask] = item / (diff[mask] + 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins < max_capacity, 2 * item - bins + 1, 0)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = bins != max_capacity\\n\\n scores[mask] = (item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff == item] = item\\n scores[diff != item] = np.log(item) / (diff[diff != item] + 0.001)\\n scores[bins == max_capacity] = 0\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores = np.log(item) / (diff + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.where(bins != max_capacity, item / (diff + 1), 0)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins != max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins])) + item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item - bins[used_bins] + 1) / (1 + bins[used_bins] - item)\\n\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item + 0.001)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = item / (1 + bins[bins != max_capacity] - item)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_31.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[(item == bins) | (bins == max_capacity)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == np.max(bins))] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, item - np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n scores[used_bins] = (item**2 * np.exp(-np.abs(bins[used_bins] - item))) / (np.log(item + 1) + 1)\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff < item] = item / (diff[diff < item] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = bins != max_capacity\\n scores[mask] = item / (diff[mask] + 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins < max_capacity, 2 * item - bins + 1, 0)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = bins != max_capacity\\n\\n scores[mask] = (item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2*item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1) / (bins[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = item / (np.maximum(diff[mask], 1)) ** 2\\n\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores = np.log(item) / (diff + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.where(bins != max_capacity, item / (diff + 1), 0)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores = np.exp(-diff) * item\\n scores[diff == item] = 1\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item - bins[used_bins] + 1) / (1 + bins[used_bins] - item)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_32.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n \\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (3 * item + 7) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 4) / (item + 2)\\n \\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins - item\\n \\n # calculate scores for each bin\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[diff > 0] = diff[diff > 0] / (item + 0.001)\\n scores[(item == bins) | (bins == max_capacity)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, item - np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n scores[used_bins] = (item**2 * np.exp(-np.abs(bins[used_bins] - item))) / (np.log(item + 1) + 1)\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff < item] = item / (diff[diff < item] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = bins != max_capacity\\n scores[mask] = item / (diff[mask] + 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins < max_capacity, 2 * item - bins + 1, 0)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = bins != max_capacity\\n\\n scores[mask] = (item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2*item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1) / (bins[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = item * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(bins[used_bins] - item)) + np.log(item + 1)\\n\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_33.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n \\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n diff = bin_capacity - item\\n score = (3 * item + 7) * np.exp(-np.abs(diff - item)) + np.log(item + 2) / (diff + 0.001)\\n if diff == item:\\n scores[i] = item * (diff + 4) / (item + 2)\\n else:\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (3 * item + 7) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 4) / (item + 2)\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 7) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 4) / (item + 2)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins - item\\n \\n # calculate scores for each bin\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n diff = bins - item\\n\\n scores[used_bins] = 2 * item * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n diff = bins - item\\n\\n scores[used_bins] = (2 * item * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)) * (item != diff[used_bins])\\n\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n used_bins = bins < max_capacity\\n \\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n \\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n \\n scores = np.zeros_like(bins)\\n \\n mask = (diff > 0) & (bins != max_capacity)\\n \\n scores[mask] = diff[mask] / (item + 0.001)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, item - np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n scores[used_bins] = (item**2 * np.exp(-np.abs(bins[used_bins] - item))) / (np.log(item + 1) + 1)\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff < item] = item / (diff[diff < item] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = bins != max_capacity\\n scores[mask] = item / (diff[mask] + 1)\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins < max_capacity, 2 * item - bins + 1, 0)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_34.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n diff = bins - item\\n scores[mask] = (item * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n \\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n diff = bin_capacity - item\\n score = (3 * item + 7) * np.exp(-np.abs(diff - item)) + np.log(item + 2) / (diff + 0.001)\\n if diff == item:\\n scores[i] = item * (diff + 4) / (item + 2)\\n else:\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 7) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 4) / (item + 2)\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[diff == item] = item\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins - item\\n\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n diff = bins - item\\n\\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n diff = bins - item\\n\\n scores[used_bins] = (2 * item * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)) * (item != diff[used_bins])\\n\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1e-10) / (item + 1e-10)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n used_bins = bins < max_capacity\\n\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n \\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n scores[diff == item] = item\\n scores[item == bins] = item\\n \\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = np.log(item) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, -1, item - np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_35.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n diff = bins - item\\n scores[mask] = (item * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = diff >= 0\\n \\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n diff = bin_capacity - item\\n score = (3 * item + 7) * np.exp(-np.abs(diff - item)) + np.log(item + 2) / (diff + 0.001)\\n scores[i] = item * (diff + 4) / (item + 2) if diff == item else score\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = (item + 1) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[diff == item] = item\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins - item\\n\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n diff = bins - item\\n\\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = bins < max_capacity\\n diff = bins - item\\n\\n scores[used_bins] = (2 * item * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)) * (item != diff[used_bins])\\n\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1e-10) / (item + 1e-10)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n scores[diff == item] = item\\n scores[item == bins] = item\\n \\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_36.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = bins < max_capacity\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (3 * item - np.abs(diff[used_bins] - item) + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = diff >= 0\\n \\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (item * 2 + 3) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 4) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n diff = bins - item\\n \\n scores[mask] = (item + 1) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[diff == item] = item\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n diff = bins - item\\n\\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n \\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (bins[used_bins] - item + 1) / (item + 0.001)\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1e-10) / (item + 1e-10)\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (2 * item + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = rest_capacity[rest_capacity > 0] / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[item == bins] = item\\n\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins - item\\n\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 3) / (item + 1)\\n scores[(item == bins) | (np.max(bins) == bins)] = 0\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_37.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = bins < max_capacity\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (3 * item - np.abs(diff[used_bins] - item) + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n # Calculate scores for bins\\n diff = bins - item\\n used_bins = diff < max_capacity\\n scores[used_bins] = (4 * item - np.abs(diff[used_bins] - item) + 3) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n scores[used_bins] = (item - np.abs(diff[used_bins] - item) + 3) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n # Calculate the difference between the bins' capacities and item size\\n diff = bins - item\\n\\n # Calculate the scores for each bin using the modified formula\\n scores = item * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n \\n # Set the scores of bins with maximum capacity to 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = diff >= 0\\n \\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (5 * item + 4) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.where(bins == max_capacity, 0, (3 * item + 2) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001))\\n\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = bins < max_capacity\\n \\n scores[mask] = (2 * item + 1) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n scores[used_bins] = (4 * item - np.abs(diff - item) + 3) * np.exp(-np.abs(diff - item)) + np.log(item + 2) / (diff + 0.001)\\n\\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n mask = bins < max_capacity\\n scores[mask] = (item * 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 4) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n scores[used_bins] = (3 * item - np.abs(diff - item) + 2) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (diff[used_bins] + 1) / (item + 0.001)\\n scores[diff == item] = item\\n scores[diff < item] = item / (diff[diff < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n used_bins = bins != max_capacity\\n \\n diff = bins[used_bins] - item\\n scores[used_bins] = (2 * item - np.abs(diff - item) + 1) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n diff = bins - item\\n\\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n scores[used_bins] = (item + 1) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n \\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (bins[used_bins] - item + 1) / (item + 0.001)\\n scores[bins == item] = item\\n\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_38.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = bins < max_capacity\\n\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 15) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n used_bins = bins < max_capacity\\n \\n scores[used_bins] = (item ** 2 + np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (3 * item - np.abs(diff[used_bins] - item) + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = diff < max_capacity\\n scores[used_bins] = (2 * item + np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 4) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff + 3) * np.exp(-abs_diff) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n\\n scores[used_bins] = (5 * item - np.abs(diff - item) + 2) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n # Calculate the difference between the bins' capacities and item size\\n diff = bins - item\\n\\n # Calculate the scores for each bin using a modified formula\\n scores = item * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n \\n # Set the scores of bins with maximum capacity to 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = diff >= 0\\n \\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (5 * item + 4) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.where(bins == max_capacity, 0, (3 * item + 2) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001))\\n\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = bins < max_capacity\\n \\n scores[mask] = (2 * item + 1) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n scores[used_bins] = (4 * item - np.abs(diff - item) + 3) * np.exp(-np.abs(diff - item)) + np.log(item + 2) / (diff + 0.001)\\n\\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n mask = bins < max_capacity\\n scores[mask] = (item * 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item * (diff[diff == item] + 4) / (item + 1)\\n\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n scores[used_bins] = (3 * item + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n scores[used_bins] = (3 * item - np.abs(diff - item) + 2) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_39.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = np.nonzero(bins < total_capacity)[0]\\n unused_bins = np.nonzero(bins == total_capacity)[0]\\n diff = bins - item\\n \\n scores[used_bins] = (item ** 2 + np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n scores[unused_bins] = (item - np.abs(diff[unused_bins])) * np.exp(-np.abs(diff[unused_bins] - item)) + np.log(item + 1) / (diff[unused_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 15) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n unused_bins = np.nonzero(bins == max_capacity)[0]\\n scores[unused_bins] = 0\\n\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + np.abs(diff[mask] - item) + 1) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (4 * item - np.abs(diff[used_bins] - item) + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 3) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0331,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (3 * item - np.abs(diff[used_bins] - item) + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n\\n scores[used_bins] = (10 * item - np.abs(diff - item) + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.01)\\n\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (2 * item - np.abs(diff[used_bins] - item) + 4) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff + 3) * np.exp(-abs_diff) + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n\\n scores[used_bins] = (5 * item - np.abs(diff - item) + 2) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n # Calculate the difference between the bins' capacities and item size\\n diff = bins - item\\n\\n # Calculate the scores for each bin using a modified formula\\n scores = item * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.001)\\n \\n # Set the scores of bins with maximum capacity to 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n mask = diff >= 0\\n \\n scores[mask] = item * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n idx = bins != max_cap\\n scores[idx] = np.minimum(1, item / bins[idx])\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = (bins / (bins - item)).clip(0, 1)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = -np.inf\\n elif bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = (item - min_cap) / (item - bins[i])\\n \\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.where(bins == max_cap, -np.inf, np.where(bins > item, item / bins, 0))\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = 0\\n elif bins[i] == min_cap:\\n scores[i] = 1\\n else:\\n scores[i] = 1 - ((item - bins[i])/(item - min_cap))\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (bins[mask] - item)\\n \\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.where(full_bins, 0, rest_capacity / np.maximum(rest_capacity, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n \\n mask = (bins > min_capacity) & (bins < max_capacity)\\n scores[mask] = (bins[mask] - item) / (bins[mask] - min_capacity)\\n \\n return scores\",\n \"objective\": 0.05574,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = -np.inf\\n elif bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = np.exp((item - min_cap) / (item - bins[i]))\\n \\n return scores\",\n \"objective\": 0.05644,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_capacity = np.max(bins)\\n capacities = np.where(bins == max_bin_capacity, 0, bins - item)\\n scores = np.where(capacities < item, 0, capacities)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n \\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n for i in range(num_bins):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (max_capacity - bins[i]) / (bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.06681,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n min_cap = bins.min()\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_cap\\n scores[mask] = (bins[mask] - item) / (bins[mask] - min_cap)\\n \\n return scores\",\n \"objective\": 0.06791,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_40.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (item ** 2 + np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n unused_bins = bins == max_capacity\\n scores[unused_bins] -= 1\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 2 + 10) * np.exp(-np.abs(diff - item)) + np.log(item + 7) / (diff + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 15) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 15) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 20) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n \\n unused_bins = np.nonzero(bins == max_capacity)[0]\\n scores[unused_bins] = 0\\n\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + np.abs(diff[mask] - item) + 1) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (4 * item - np.abs(diff[used_bins] - item) + 5) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 3) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.0331,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (3 * item - np.abs(diff[used_bins] - item) + 2) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n unused_bins = np.nonzero(bins == max_capacity)[0]\\n scores[unused_bins] = 0\\n\\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n used_bins = bins < max_capacity\\n diff = bins[used_bins] - item\\n\\n scores[used_bins] = (10 * item - np.abs(diff - item) + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 1) / (diff + 0.01)\\n\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_41.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (item ** 2 + np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = diff >= 0\\n scores[mask] = ((np.exp(-np.abs(diff[mask] - item)) * item ** 2 + 3) + np.log(item + 5) / (diff[mask] + 0.001))\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 2 + 10) * np.exp(-np.abs(diff - item)) + np.log(item + 7) / (diff + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 15) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 15) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 20) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n unused_bins = np.nonzero(bins == max_capacity)[0]\\n scores[unused_bins] = 0\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n unused_bins = np.nonzero(bins == max_capacity)[0]\\n scores[unused_bins] = 0\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = np.power((item + 10), 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 20) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n\\n mask = bins < max_capacity\\n\\n scores[mask] = (10 * item + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + np.abs(diff[mask] - item) + 1) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 1) / (diff[mask] + 0.001)\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_42.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (5 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n scores[used_bins] = (item ** 2 + np.abs(diff[used_bins] - item) + 1) * np.exp(-np.abs(diff[used_bins] - item)) + np.log(item + 1) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = diff >= 0\\n scores[mask] = ((np.exp(-np.abs(diff[mask] - item)) * item ** 2 + 3) + np.log(item + 5) / (diff[mask] + 0.001))\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n scores = (item ** 2 + 10) * np.exp(-np.abs(diff - item)) + np.log(item + 7) / (diff + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item ** 2\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 15) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 20) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n unused_bins = np.nonzero(bins == max_capacity)[0]\\n scores[unused_bins] = 0\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n remaining_capacity = diff[diff >= 0]\\n \\n scores[diff >= 0] = (item ** 3 + 5) * np.exp(-np.abs(remaining_capacity - item)) + np.log(item + 2) / (remaining_capacity + 0.001)\\n scores[diff == item] = item\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n unused_bins = np.nonzero(bins == max_capacity)[0]\\n scores[unused_bins] = 0\\n\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = np.power((item + 10), 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 20) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_43.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (10 * item ** 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (5 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 1\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n # Calculate the scores based on the size of the item and the difference from the bin capacity\\n scores = (3 * item ** 2 + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 3) / (diff + 0.001)\\n \\n # Set the scores for bins with the same capacity as the item to be twice the item size\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = diff >= 0\\n scores[mask] = ((np.exp(-np.abs(diff[mask] - item)) * item ** 2 + 3) + np.log(item + 5) / (diff[mask] + 0.001))\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n \\n scores = (item ** 2 + 10) * np.exp(-np.abs(diff - item)) + np.log(item + 7) / (diff + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 3 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item ** 2\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 15) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 20) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_44.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n # Calculating scores using a modified formula\\n scores[mask] = (5 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 3) * np.log(item + 3)\\n\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (10 * item ** 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (5 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 1\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n scores = np.where(diff == item, item * 2, (3 * item ** 2 + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 3) / (diff + 0.001))\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n mask = diff >= 0\\n scores[mask] = ((np.exp(-np.abs(diff[mask] - item)) * item ** 2 + 3) + np.log(item + 5) / (diff[mask] + 0.001))\\n scores[diff == item] = item\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n \\n scores = (item ** 2 + 10) * np.exp(-np.abs(diff - item)) + np.log(item + 7) / (diff + 0.001)\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (item ** 3 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_45.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 5\\n\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n # Calculating scores using a modified formula\\n scores[mask] = (5 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 3) * np.log(item + 3)\\n\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (6 * item ** 2 + 11) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (10 * item ** 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (5 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 1\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n scores = np.where(diff == item, item * 2, (3 * item ** 2 + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 3) / (diff + 0.001))\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the difference between the bins and the item size\\n diff = bins - item\\n \\n # Calculate the scores for each bin based on the new formula\\n scores = (np.exp(-np.abs(diff - item)) * item ** 2) + (3 * np.heaviside(diff, 0)) + np.log(item + 5) / (diff + 0.001)\\n \\n # Set the scores of bins with the same capacity as item to item\\n scores[diff == item] = item\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_46.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 5\\n\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (10 * item ** 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 1\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n scores = np.where(diff == item, item * 2, (3 * item ** 2 + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 3) / (diff + 0.001))\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_47.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 5) / (diff[used_bins] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = (item + 2) * np.log(item + 2)\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 5\\n\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (10 * item ** 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 1\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n \\n scores = np.where(diff == item, item * 2, (3 * item ** 2 + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 3) / (diff + 0.001))\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (item ** 2 + 3) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item\\n\\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_48.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 5) / (diff[used_bins] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + item) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n # Modify the scoring formula here\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.power(item, 2) + np.cos(item)\\n\\n return scores\",\n \"objective\": 0.02827,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item) + np.cos(item)\\n scores[diff == item] = item + 4\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 5\\n\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (10 * item ** 2) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 6) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 2) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 1\\n\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (6 * item ** 2 + 12) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001) + np.power(item, 3) + np.sin(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_49.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins = len(bins)\\n scores = np.zeros_like(bins)\\n\\n remaining_capacity = bins - item\\n\\n # Assign maximum score to bins with remaining capacity equal to the maximum capacity\\n scores[remaining_capacity == max_capacity] = item + 5\\n\\n # Assign scores to bins with remaining capacity greater than zero\\n mask = remaining_capacity > 0\\n diff = remaining_capacity[mask] - item\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff - item)) + np.log(item + 8) / (diff + 0.001) + np.sqrt(item)\\n\\n # Assign scores to bins with remaining capacity less than the item size\\n mask = remaining_capacity < item\\n scores[mask] = item / (remaining_capacity[mask]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 5) / (diff[used_bins] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores = np.zeros_like(bins)\\n scores[mask] = (7 * item ** 2 + 14) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + item) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n # Modify the scoring formula here\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.power(item, 2) + np.cos(item)\\n\\n return scores\",\n \"objective\": 0.02827,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item) + np.cos(item)\\n scores[diff == item] = item + 4\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 5\\n\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (2 * item ** 2 + 4) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores = np.zeros_like(bins)\\n\\n scores[mask] = (10 * item ** 2) / np.exp(np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (3 * item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 3) / (diff[mask] + 0.001)\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n non_zero_capacity = bins[bins != 0]\\n \\n if item >= max_capacity:\\n scores[np.argmax(bins)] = 0\\n else:\\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n idx = bins != max_cap\\n scores[idx] = np.minimum(1, item / bins[idx])\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = (bins / (bins - item)).clip(0, 1)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(len(bins))\\n \\n for i, bin_size in enumerate(bins):\\n if bin_size == max_cap:\\n scores[i] = -np.inf\\n elif bin_size == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = (item - min_cap) / (item - bin_size)\\n \\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0.0 # Added line to exclude bins with maximum capacity\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.where(bins == max_cap, -np.inf, np.where(bins > item, item / bins, 0))\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = 0\\n elif bins[i] == min_cap:\\n scores[i] = 1\\n else:\\n scores[i] = 1 - ((item - bins[i])/(item - min_cap))\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (bins[mask] - item)\\n \\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.where(full_bins, 0, rest_capacity / np.maximum(rest_capacity, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores[bins == max_capacity] = 0\\n \\n mask = (bins > min_capacity) & (bins < max_capacity)\\n scores[mask] = (bins[mask] - item) / (bins[mask] - min_capacity)\\n \\n return scores\",\n \"objective\": 0.05574,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n if bins[i] == max_cap:\\n scores[i] = -np.inf\\n elif bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = np.exp((item - min_cap) / (item - bins[i]))\\n\\n return scores\",\n \"objective\": 0.05644,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_capacity = np.max(bins)\\n capacities = np.where(bins == max_bin_capacity, 0, bins - item)\\n scores = np.where(capacities < item, 0, capacities)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_50.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.power(item, 2) / (diff[used_bins] + 0.001) + np.sqrt(item) + (diff[used_bins] / (item + 0.001))\\n\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n remaining_capacity = bins - item\\n\\n # Assign maximum score to bins with remaining capacity equal to the maximum capacity\\n scores[remaining_capacity == max_capacity] = item + 5\\n\\n # Assign scores to bins with remaining capacity greater than zero\\n mask = remaining_capacity > 0\\n diff = remaining_capacity[mask] - item\\n scores[mask] = 2 * (item ** 2 + 5) * np.exp(-np.abs(diff - item)) + np.log(item + 7) / (diff + 0.001) + np.sqrt(item) + (diff / (item + 0.001))\\n\\n # Assign scores to bins with remaining capacity less than the item size\\n mask = remaining_capacity < item\\n scores[mask] = item / (remaining_capacity[mask]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity == max_capacity] = item + 5\\n\\n mask = remaining_capacity > 0\\n diff = remaining_capacity[mask] - item\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff - item)) + np.log(item + 8) / (diff + 0.001) + np.sqrt(item)\\n\\n mask = remaining_capacity < item\\n scores[mask] = item / (remaining_capacity[mask]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n diff = bins - item\\n \\n scores[diff == item] = item + 2\\n scores[(diff > item) & (diff < max_capacity)] = np.power(item, 2) + np.log(item + 5) / (diff[(diff > item) & (diff < max_capacity)] + 0.001) + np.sqrt(item)\\n scores[diff < item] = item / (diff[diff < item] ** 2 + 0.001)\\n \\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 10) / (diff[used_bins] + 0.001) + np.sqrt(item) * np.cos(item)\\n\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = 2 * (item ** 2 + 5) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 2) / (diff[used_bins] + 0.001)\\n\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 5) / (diff[used_bins] + 0.001) + np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n used_bins = diff < max_capacity\\n\\n abs_diff = np.abs(diff[used_bins] - item)\\n scores[used_bins] = (item - abs_diff)**2 + np.log(item + 5) / (diff[used_bins] + 0.001) + np.power(item, 2) + np.cos(item)\\n\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item * 2\\n\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 7) / (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores = np.zeros_like(bins)\\n scores[mask] = (7 * item ** 2 + 14) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 10) / (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + item) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores = np.zeros_like(bins)\\n scores[mask] = np.floor((7 * item ** 2 + 14) * np.exp(-np.abs(diff[mask] - item))) + np.log(item + 10) // (diff[mask] + 0.001) + np.sqrt(item) + (diff[mask] / (item + 0.001))\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n scores[remaining_capacity > 0] = (remaining_capacity[remaining_capacity > 0] + 1) / (item + 0.001)\\n scores[remaining_capacity == item] = item\\n scores[remaining_capacity < item] = item / (remaining_capacity[remaining_capacity < item]**2 + 0.001)\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 7) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 5) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n # Modify the scoring formula here\\n scores[mask] = (5 * item ** 2 + 10) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.power(item, 2) + np.cos(item)\\n\\n return scores\",\n \"objective\": 0.02827,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (4 * item ** 2 + 8) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 6) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 2\\n\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n diff = bins - item\\n mask = diff >= 0\\n\\n scores[mask] = (3 * item ** 2 + 12) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 4) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 3\\n\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = np.zeros_like(bins)\\n\\n mask = diff >= 0\\n scores[mask] = (4 * item ** 2 + 9) * np.exp(-np.abs(diff[mask] - item)) + np.log(item + 8) / (diff[mask] + 0.001) + np.sqrt(item)\\n scores[diff == item] = item + 5\\n\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n min_capacity = np.min(bins)\\n \\n feasible_bins = np.where(bins > item)[0]\\n if len(feasible_bins) > 0:\\n scores[feasible_bins] = 1 - (item / min_capacity) * bins[feasible_bins]\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n if item >= max_capacity:\\n scores[np.argmax(bins)] = 0\\n else:\\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n idx = bins != max_cap\\n scores[idx] = np.minimum(1, item / bins[idx])\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(len(bins))\\n \\n for i, bin_size in enumerate(bins):\\n if bin_size == max_cap:\\n scores[i] = -np.inf\\n elif bin_size == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = (item - min_cap) / (item - bin_size)\\n \\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n max_cap_bins = np.where(bins == max_cap)[0]\\n\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[max_cap_bins] = 0.0\\n\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.where(bins == max_cap, -np.inf, np.where(bins > item, item / bins, 0))\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n min_capacity = np.min(bins[feasible_bins])\\n \\n if len(feasible_bins) > 0:\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n if bins[i] == max_cap or bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = 1 - ((item - bins[i])/(item - min_cap))\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (bins[mask] - item)\\n \\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.where(full_bins, 0, rest_capacity / np.maximum(rest_capacity, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros_like(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_cap or bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = max_cap - bins[i] + (bins[i] == max_cap) * item\\n\\n return scores\",\n \"objective\": 0.05433,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.zeros_like(bins)\\n scores[~full_bins] = item / np.maximum(rest_capacity[~full_bins], 1)\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n if item >= max_capacity:\\n scores[np.argmax(bins)] = 0\\n else:\\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = item / rest_capacity[rest_capacity > 0]\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n \\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n scores[(bins - item) <= 0] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n min_capacity = np.min(bins[feasible_bins])\\n \\n if len(feasible_bins) > 0:\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n if bins[i] == max_cap or bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = 1 - ((item - bins[i])/(item - min_cap))\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (bins[mask] - item)\\n\\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.where(full_bins, 0, rest_capacity / np.maximum(rest_capacity, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.zeros_like(bins)\\n scores[~full_bins] = item / np.maximum(rest_capacity[~full_bins], 1)\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n scores = np.where(bins == max_capacity, 0, item / np.maximum(rest_capacity, 1))\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n rest_capacity = bins - item\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = item / rest_capacity[rest_capacity > 0]\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = (max_cap - bins[mask] + 1) / (bins[mask] - item + 1)\\n \\n scores[bins == max_cap] = 0\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n min_capacity = np.min(bins[feasible_bins])\\n \\n if len(feasible_bins) > 0:\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n\\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n if bins[i] == max_cap or bins[i] == min_cap:\\n scores[i] = 0\\n else:\\n scores[i] = 1 - ((item - bins[i])/(item - min_cap))\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (bins[mask] - item)\\n\\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n full_bins = (bins == max_capacity)\\n rest_capacity = bins - item\\n \\n scores = np.zeros_like(bins)\\n scores[~full_bins] = item / np.maximum(rest_capacity[~full_bins], 1)\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n scores[bins != max_capacity] = 1 / np.maximum((bins[bins != max_capacity] - item), 1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n\\n scores = np.where(bins == max_capacity, 0, item / np.maximum(rest_capacity, 1))\\n\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.maximum(0, item - bins) / bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = bins[mask] / np.maximum(1, bins[mask] - item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_cap\\n scores[mask] = np.minimum(1, item / (bins[mask] - item))\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = 1 / (bins[mask] - item)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n scores = np.where(bins == max_cap, -np.inf, scores)\\n scores = np.where(bins == min_cap, 0, scores)\\n scores = np.where((bins > min_cap) & (bins < max_cap), (item - min_cap) / (item - bins), scores)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == max_cap] = 0\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = item / (bins[mask] - item)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = bins.max()\\n scores = np.zeros_like(bins)\\n \\n mask = bins > item\\n scores[mask] = (max_cap - bins[mask] + 1) / (bins[mask] - item + 1)\\n \\n scores[bins == max_cap] = 0\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, item / bins)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins > item)[0]\\n min_capacity = np.min(bins[feasible_bins])\\n \\n if len(feasible_bins) > 0:\\n scores[feasible_bins] = (bins[feasible_bins] - item) / bins[feasible_bins]\\n scores[bins == min_capacity] = -1\\n\\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_cap = np.max(bins)\\n min_cap = np.min(bins)\\n\\n scores = np.zeros(num_bins)\\n mask = (bins != max_cap) & (bins != min_cap)\\n scores[mask] = 1 - ((item - bins[mask]) / (item - min_cap))\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (bins[mask] - item)\\n\\n return scores\",\n \"objective\": 0.05051,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_bin = bins.max()\\n scores[bins < max_bin] = bins[bins < max_bin] / (bins[bins < max_bin] - item + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n valid_bins = np.where(bins != max_capacity)[0]\\n valid_bin_capacities = bins[valid_bins]\\n\\n scores[valid_bins] = valid_bin_capacities / np.maximum((valid_bin_capacities - item), 1)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_capacity = np.max(bins)\\n weight = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / max_capacity)\\n scores = (normalized_capacity * weight) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.07637,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.10102,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins)\\n bin_capacities = bins / np.max(bins)\\n scores = bin_capacities * (bin_indices + 1)\\n scores = np.where(bins == np.max(bins), 0, scores)\\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins + item - max_capacity\\n scores[bins == max_capacity] = -1\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy() # create a copy of bins\\n capacities[capacities == capacities.max()] = 0 # Ignore bins with maximum capacity\\n\\n scores = np.zeros_like(bins) \\n scores[capacities >= item] = -capacities[capacities >= item]/item + 1\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n indices = np.where(bins >= item)\\n scores[indices] = -bins[indices]/item + (bins[indices] == bins[indices].max())\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = bins[mask] / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - item) / (max_capacity - bins[mask])\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = (bins > item) & (bins != bins.max())\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask1 = bins < max_capacity\\n mask2 = bins >= item\\n \\n scores[mask1] = bins[mask1] / (bins[mask1] - item + 1)\\n scores[bins == item] = -1\\n scores[bins == max_capacity] = -2\\n scores[~(mask1 | mask2)] = -3\\n \\n return scores\",\n \"objective\": 0.04689,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy() # create a copy of bins\\n capacities[capacities == capacities.max()] = 0 # Ignore bins with maximum capacity\\n\\n scores = np.zeros_like(bins) \\n scores[capacities >= item] = -capacities[capacities >= item]/item + 1\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n indices = np.where(bins >= item)\\n scores[indices] = -bins[indices]/item + (bins[indices] == bins[indices].max())\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = bins[mask] / np.maximum((bins[mask] - item), 1)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(1, np.maximum(bins - item, 1), where=bins != bins.max()) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, copy=True)\\n capacities[capacities == capacities.max()] = 0\\n\\n scores = np.zeros_like(bins)\\n valid_bins = capacities >= item\\n scores[valid_bins] = -capacities[valid_bins]/item + 1\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins >= item\\n scores[mask] = -bins[mask] / item + (bins[mask] == np.max(bins[mask]))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = bins[mask] / np.maximum((bins[mask] - item), 1)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(1, np.maximum(bins - item, 1), where=bins != bins.max()) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, copy=True)\\n capacities[capacities == capacities.max()] = 0\\n\\n scores = np.zeros_like(bins)\\n valid_bins = capacities >= item\\n scores[valid_bins] = -capacities[valid_bins]/item + 1\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins >= item\\n scores[mask] = -bins[mask] / item + (bins[mask] == np.max(bins[mask]))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = bins[mask] / np.maximum((bins[mask] - item), 1)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, copy=True)\\n capacities[capacities == capacities.max()] = 0\\n\\n scores = np.zeros_like(bins)\\n valid_bins = capacities >= item\\n scores[valid_bins] = -capacities[valid_bins]/item + 1\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = (bins[mask] - item) / item\\n scores[~mask] = (max_capacity - bins[~mask] + item) / item\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins >= item\\n scores[mask] = -bins[mask] / item + (bins[mask] == np.max(bins[mask]))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n valid_bins = bins >= item\\n scores[valid_bins] = (item - bins[valid_bins]) / item + 1\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n \\n mask = bins < max_capacity\\n scores[mask] = 1 - bins[mask] / (item + 1)\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = (bins[mask] - item) / item\\n scores[~mask] = (max_capacity - bins[~mask] + item) / item\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, np.exp(-bins/item))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n valid_bins = bins >= item\\n scores[valid_bins] = (item - bins[valid_bins]) / item + 1\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n \\n mask = bins < max_capacity\\n scores[mask] = 1 - bins[mask] / (item + 1)\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = (bins[mask] - item) / item\\n scores[~mask] = (max_capacity - bins[~mask] + item) / item\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = -(bins[bins != max_capacity] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n \\n mask = bins < max_capacity\\n scores[mask] = 1 - bins[mask] / (item + 1)\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = (bins[mask] - item) / item\\n scores[~mask] = (max_capacity - bins[~mask] + item) / item\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = -(bins[bins != max_capacity] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n \\n mask = bins < max_capacity\\n scores[mask] = 1 - bins[mask] / (item + 1)\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = -(bins[bins != max_capacity] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n \\n mask = bins < max_capacity\\n scores[mask] = 1 - bins[mask] / (item + 1)\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_bin\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n valid_bins = np.where(bins != max_capacity)[0]\\n valid_bin_capacities = bins[valid_bins]\\n\\n scores[valid_bins] = valid_bin_capacities / np.maximum((valid_bin_capacities - item), 1)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n scores[rest_capacity == 0] = -99999999\\n scores[rest_capacity != 0] = rest_capacity[rest_capacity != 0] / max_capacity\\n \\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_capacity = np.max(bins)\\n weight = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / max_capacity)\\n scores = (normalized_capacity * weight) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.07637,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.10102,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins)\\n bin_capacities = bins / np.max(bins)\\n scores = bin_capacities * (bin_indices + 1)\\n scores = np.where(bins == np.max(bins), 0, scores)\\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 - item / bins\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = -(bins[bins != max_capacity] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] + 1)\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = -(bins - item) / item + (bins == max_capacity)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mask = bins == np.max(bins)\\n scores = np.where(mask, 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = -(bins[bins != max_capacity] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] /item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] + 1)\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mask = bins == np.max(bins)\\n scores = np.where(mask, 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = -(bins[bins != max_capacity] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mask = bins == np.max(bins)\\n scores = np.where(mask, 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = -(bins[bins != max_capacity] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item / (bins[bins == max_capacity] + 1)\\n scores[bins < max_capacity] = 1 - bins[bins < max_capacity] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mask = bins == np.max(bins)\\n scores = np.where(mask, 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = max_capacity // (bins[~mask] - item + 1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n idx = (bins != max_capacity)\\n scores[idx] = -(bins[idx] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mask = bins == np.max(bins)\\n scores = np.where(mask, 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = max_capacity // (bins[~mask] - item + 1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = -(bins[mask] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_26.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mask = bins == np.max(bins)\\n scores = np.where(mask, 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = -(bins[mask] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_27.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = (bins == max_capacity)\\n scores = np.where(mask, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = -(bins[mask] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (item - bins[mask]) / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_28.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = (bins == max_capacity)\\n scores = np.where(mask, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = ((max_capacity - bins[mask]) ** 2) / (item ** 2)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = -(bins[mask] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (item - bins[mask]) / item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_29.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n # Calculate the scores for bins using a modified formula\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + (bins[mask] - item)**2)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + bins[mask] - item)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 2) / (item ** 2)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = -(bins[mask] - item) / item + 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_bin\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.empty_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / np.maximum(bins[~mask] - item, 1)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -2 * i\\n else:\\n scores[i] = bins[i] - item - 2 * i\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = bins[~mask] / (bins[~mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores[mask] = 0\\n scores[~mask] = (bins[~mask] - item) / np.maximum(bins[~mask] - item, 1)\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores[mask] = 0\\n scores[~mask] = item / (bins[~mask] - item) - (2 * np.arange(len(bins)))[~mask]\\n return scores\",\n \"objective\": 0.05242,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n else:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins)\\n normalized_bin_capacities = 1 - bins / np.max(bins)\\n scores = normalized_bin_capacities * (bin_indices + 1) + item\\n scores = np.where(bins == np.max(bins), 0, scores)\\n return scores\",\n \"objective\": 0.05826,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n \\n scores[bins == np.max(bins)] = 0 # assign 0 score to bin with maximum capacity\\n \\n return scores\",\n \"objective\": 0.06429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_30.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n # Calculate the scores for bins using a modified formula\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + (bins[mask] - item)**2)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (3 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 2)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (2 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 2) / (item ** 2)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_31.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the scores for bins\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + (bins[mask] - item)**2)\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n # Calculate the scores for bins using a modified formula\\n scores[mask] = (2 * (max_capacity - bins[mask]) * (bins[mask] >= item)) / (1 + (bins[mask] - item)**2)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (3 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 2)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (2 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 2) / (item ** 2)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_32.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the scores for bins\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + (bins[mask] - item)**2)\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (max_capacity - bins[mask]) * (bins[mask] >= item) / (1 + (bins[mask] - item) ** 2)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (3 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 2)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (2 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 2) / (item ** 2)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n # Calculate the score based on the modified formula\\n scores[mask] = ((max_capacity - bins[mask]) ** 3) / (item ** 3)\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_33.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n # Calculate the scores for bins\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + (bins[mask] - item)**2)\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (max_capacity - bins[mask]) * (bins[mask] >= item) / (1 + (bins[mask] - item) ** 2)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (3 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 2)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (2 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 2) / (item ** 2)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = ((max_capacity - bins[mask]) ** 3) / (item ** 3)\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_34.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (max_capacity - bins[mask]) * (bins[mask] >= item) / (1 + (bins[mask] - item) ** 2)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = (3 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 2)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (2 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 1)\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 2) / (item ** 2)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_35.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (max_capacity - bins[mask]) * (bins[mask] >= item) / (1 + (bins[mask] - item) ** 2)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask] + 1) * (bins[mask] >= item)) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask])) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (4 * (max_capacity - bins[mask])) / item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_36.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (max_capacity - bins[mask]) * (bins[mask] >= item) / (1 + (bins[mask] - item) ** 2)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) * (bins[mask] >= item)) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) * (bins[mask] >= item) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins) / item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.where(mask, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = 2 * (max_capacity - bins[mask]) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_37.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (max_capacity - bins[mask]) * (bins[mask] >= item) / (1 + (bins[mask] - item) ** 2)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) * (bins[mask] >= item)) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) * (bins[mask] >= item) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = 2 * (max_capacity - bins[mask]) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_38.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) * (bins[mask] >= item) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (np.sqrt(max_capacity - bins[mask]) / (1 + (bins[mask] - item) ** 2))\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_39.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) * (bins[mask] >= item) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = (np.sqrt(max_capacity - bins[mask]) / (1 + (bins[mask] - item) ** 2))\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_bin\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins >= item] = -bins[bins >= item] / item + (bins[bins >= item] == max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.empty_like(bins)\\n scores[mask] = 0\\n scores[~mask] = bins[~mask] / np.maximum(bins[~mask] - item, 1)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n \\n scores[~mask] = (max_capacity - item) / (max_capacity - bins[~mask])\\n scores[bins == max_capacity] = -1\\n \\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = bins[~mask] / (bins[~mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == np.max(bins), 0, (bins - item) / np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores[~mask] = item / (bins[~mask] - item) - (2 * np.arange(len(bins)))[~mask]\\n return scores\",\n \"objective\": 0.05242,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum((bins - item) / np.maximum(bins - item, 1), 0)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins)\\n normalized_bin_capacities = 1 - bins / np.max(bins)\\n scores = normalized_bin_capacities * (bin_indices + 1) + item\\n scores = np.where(bins == np.max(bins), 0, scores)\\n return scores\",\n \"objective\": 0.05826,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_40.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item) ** 2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_41.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item) ** 2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_42.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item) ** 2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_43.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item) ** 2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_44.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item) ** 2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_45.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item)) + np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / np.exp(bins[mask] - item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item) ** 2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = ((max_capacity - bins[mask]) ** 4) / (item ** 4)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_46.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item)) + np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = max_capacity / np.power(bins[mask] - item + 1, 2)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / np.exp(bins[mask] - item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / (bins[mask] + 1)\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item)**2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_47.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item)) + np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = max_capacity / np.power(bins[mask] - item + 1, 2)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / np.exp(bins[mask] - item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (3 * (max_capacity - bins[mask]) - item + 1) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / bins[mask]\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item)**2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_48.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item)) + np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = max_capacity / np.power(bins[mask] - item + 1, 2)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / np.exp(bins[mask] - item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.square(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) + item) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / bins[mask]\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n\\n scores[mask] = np.exp(-(bins[mask] - item)**2) * (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_49.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item)) + np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = max_capacity / ((bins[mask] - item + 1)**2)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / np.exp(bins[mask] - item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = ((2 * max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)) * (bins[mask] - item < max_capacity)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * (max_capacity - bins[mask]) + item) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / bins[mask]\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = np.exp(-(bins[mask] - item)**2) * (max_capacity - bins[mask])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (np.abs(bins[mask] - item) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_bin\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins >= item] = -bins[bins >= item] / item + (bins[bins >= item] == max_capacity)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = (bins[~mask] / np.maximum(bins[~mask] - item, 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins == max_capacity] = -1\\n scores[bins != max_capacity] = (max_capacity - item) / (max_capacity - bins[bins != max_capacity])\\n \\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n scores[bins == item] = -1\\n \\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = bins[~mask] / (bins[~mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == np.max(bins), 0, (bins - item) / np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores[~mask] = item / (bins[~mask] - item) - (2 * np.arange(len(bins)))[~mask]\\n return scores\",\n \"objective\": 0.05242,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum((bins - item) / np.maximum(bins - item, 1), 0)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_50.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item)) + np.maximum(bins[mask] - item, 1)\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / (1 + np.exp(bins[mask] - item))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = max_capacity / ((bins[mask] - item + 1)**2)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, -(bins - item) / item + 1)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / np.exp(bins[mask] - item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (2 * max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - bins[mask]) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = (max_capacity - bins[mask] + 1) / ((bins[mask] - item + 1) ** 2 + 1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item / (bins + 1), (max_capacity - bins + 1) / item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, item, (max_capacity - bins + 1) * 2)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (2 * (max_capacity - bins[mask]) + item) / (10 * (bins[mask] - item + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[mask] = item / bins[mask]\\n scores[~mask] = 1 - bins[~mask] / item\\n scores[bins == item] = 1.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins != max_capacity\\n scores[mask] = np.exp(-(bins[mask] - item)**2) * (max_capacity - bins[mask])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (2 * max_capacity - bins[mask]) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.where(bins == max_capacity, 0, max_capacity // (bins - item + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins != max_capacity\\n scores = np.where(mask, (3 * (max_capacity - bins) - item + 1) / (10 * (bins - item + 1)), 0)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n scores = np.zeros_like(bins)\\n scores[mask] = (max_capacity - item + 1) / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins < max_bin\\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n indices = np.where(bins >= item)\\n scores[indices] = -bins[indices]/item + (bins[indices] == bins[indices].max())\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = (bins[~mask] / np.maximum(bins[~mask] - item, 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - item) / (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n scores[bins == item] = -1\\n \\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = bins[~mask] / (bins[~mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == np.max(bins), 0, (bins - item) / np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores[~mask] = item / (bins[~mask] - item) - (2 * np.arange(len(bins)))[~mask]\\n return scores\",\n \"objective\": 0.05242,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum((bins - item) / np.maximum(bins - item, 1), 0)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n indices = np.where(bins >= item)\\n scores[indices] = -bins[indices]/item + (bins[indices] == bins[indices].max())\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = (bins[~mask] / np.maximum(bins[~mask] - item, 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n for i in range(len(bins)):\\n rest_capacity = bins[i]\\n \\n if rest_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - rest_capacity) / item\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - item) / (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins < max_capacity\\n \\n scores[mask] = bins[mask] / (bins[mask] - item + 1)\\n scores[bins == item] = -1\\n \\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = bins[~mask] / (bins[~mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, -1, item / bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == np.max(bins), 0, (bins - item) / np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores[~mask] = item / (bins[~mask] - item) - (2 * np.arange(len(bins)))[~mask]\\n return scores\",\n \"objective\": 0.05242,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum((bins - item) / np.maximum(bins - item, 1), 0)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item\\n scores[bins != max_capacity] = max_capacity - bins[bins != max_capacity] + 1\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins/item + (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy() # create a copy of bins\\n capacities[capacities == capacities.max()] = 0 # Ignore bins with maximum capacity\\n\\n scores = np.zeros_like(bins) \\n scores[capacities >= item] = -capacities[capacities >= item]/item + 1\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n indices = np.where(bins >= item)\\n scores[indices] = -bins[indices]/item + (bins[indices] == bins[indices].max())\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = (bins[~mask] / np.maximum(bins[~mask] - item, 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[~mask] = (max_capacity - bins[~mask]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - item) / (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = (bins > item) & (bins < max_capacity)\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask1 = bins < max_capacity\\n mask2 = bins >= item\\n \\n scores[mask1] = bins[mask1] / (bins[mask1] - item + 1)\\n scores[bins == item] = -1\\n scores[bins == max_capacity] = -2\\n scores[~(mask1 | mask2)] = -3\\n \\n return scores\",\n \"objective\": 0.04689,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores\\n scores = np.zeros_like(bins)\\n mask = bins > item\\n scores[mask] = bins[mask] / (bins[mask] - item)\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/C2C/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins // (bins - item + 1)\\n max_capacity = np.max(bins)\\n np.putmask(scores, bins == max_capacity, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = 1 / np.maximum((bins[mask] - item), 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = item\\n scores[bins != max_capacity] = max_capacity - bins[bins != max_capacity] + 1\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins == bins.max()).astype(int) - bins/item\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.maximum((bins - item), 1)) * (bins != bins.max())\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n scores[bins >= item] = (item / bins[bins >= item]) - (max_score == bins)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy() # create a copy of bins\\n capacities[capacities == capacities.max()] = 0 # Ignore bins with maximum capacity\\n\\n scores = np.zeros_like(bins) \\n scores[capacities >= item] = -capacities[capacities >= item]/item + 1\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n indices = np.where(bins >= item)\\n scores[indices] = -bins[indices]/item + (bins[indices] == bins[indices].max())\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins = bins - item\\n mask = bins == np.max(bins)\\n scores[mask] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[~mask] = (2 * (max_capacity - bins[~mask])) / item\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = bins == max_capacity\\n scores = np.zeros_like(bins)\\n scores[~mask] = (bins[~mask] / np.maximum(bins[~mask] - item, 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins == max_capacity\\n scores[~mask] = (max_capacity - bins[~mask]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item - 2 * np.arange(len(bins))).astype(float)\\n scores[bins == max_capacity] = -2 * np.arange(len(bins))[bins == max_capacity]\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n mask = bins < max_capacity\\n scores[mask] = (max_capacity - item) / (max_capacity - bins[mask])\\n\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n mask = (bins > item) & (bins < max_capacity)\\n scores = np.zeros_like(bins)\\n scores[mask] = item / (bins[mask] - item + 1)\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": null,\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n mask1 = bins < max_capacity\\n mask2 = bins >= item\\n \\n scores[mask1] = bins[mask1] / (bins[mask1] - item + 1)\\n scores[bins == item] = -1\\n scores[bins == max_capacity] = -2\\n scores[~(mask1 | mask2)] = -3\\n \\n return scores\",\n \"objective\": 0.04689,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio of item size to the remaining capacity and the reciprocal of the bin number, excluding bins with maximum capacity, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item/bins) * (1/(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the bin's remaining capacity to the inverse of the item size plus the square root of the bin number, and return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (1 / item + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Define a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins by considering the remaining capacity of bins and giving higher scores to bins with more space available.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins_with_capacity = np.nonzero(bins > item)[0]\\n scores[bins_with_capacity] = bins[bins_with_capacity] / (bins[bins_with_capacity] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -float('inf')\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] != item:\\n scores[i] = (bins[i] - item) / bins[i]\\n else:\\n scores[i] = -1\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on their remaining capacity and their proximity to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the bin's remaining capacity to the item size, and set the score to a higher value if the bin's remaining capacity is close to the item size, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the bin's remaining capacity to the item size\\n ratio = bins / item\\n \\n # Calculate the score based on the ratio and the proximity to the item size\\n scores = ratio * (1 + (1 - np.abs(ratio - 1)))\\n \\n return scores\",\n \"objective\": 0.09035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the rest capacity, the index of the bin, and a random factor, which results in a unique scoring function for bin assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores based on rest capacity, index of bin, and random factor\\n scores = rest_capacity + np.arange(len(rest_capacity)) + np.random.rand(len(rest_capacity))\\n \\n return scores\",\n \"objective\": 0.10534,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins)\\n scores = np.zeros_like(capacities)\\n \\n min_cap = np.min(capacities)\\n \\n if min_cap == item:\\n scores[np.where(capacities == min_cap)] = 0\\n else:\\n scores[np.where(capacities >= item)] = capacities[np.where(capacities >= item)] - item\\n \\n return scores\",\n \"objective\": 0.51544,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins) + np.sqrt( np.arange(len(bins)) )\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by modifying the ratio and logarithm operators used in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (np.log(ratios + 1)) / (1 + np.log(ratios))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the remaining capacity of each bin divided by the factorial of the bin number, excluding bins with maximum capacity, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty(len(bins), dtype=float)\\n max_capacity = np.amax(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = (item * (max_capacity - bins[i])) / math.factorial(i)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the cube root of the product of the bin's index and the item size, excluding bins with maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1) * item)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the logarithm of the item size and the cube root of the remaining capacity of bins, multiplied by the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(item) - np.cbrt(bins)) * np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the item size minus the remaining capacity of each bin multiplied by the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item - bins)) * np.log(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins) + np.sqrt( np.arange(len(bins)) )\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by modifying the ratio and logarithm operators used in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (np.log(ratios + 1)) / (1 + np.log(ratios))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the remaining capacity of each bin divided by the factorial of the bin number, excluding bins with maximum capacity, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty(len(bins), dtype=float)\\n max_capacity = np.amax(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = (item * (max_capacity - bins[i])) / math.factorial(i)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the cube root of the product of the bin's index and the item size, excluding bins with maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1) * item)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the logarithm of the item size and the cube root of the remaining capacity of bins, multiplied by the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(item) - np.cbrt(bins)) * np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the item size minus the remaining capacity of each bin multiplied by the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item - bins)) * np.log(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins) + np.sqrt( np.arange(len(bins)) )\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by modifying the ratio and logarithm operators used in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (np.log(ratios + 1)) / (1 + np.log(ratios))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the remaining capacity of each bin divided by the factorial of the bin number, excluding bins with maximum capacity, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty(len(bins), dtype=float)\\n max_capacity = np.amax(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = (item * (max_capacity - bins[i])) / math.factorial(i)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the cube root of the product of the bin's index and the item size, excluding bins with maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1) * item)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the logarithm of the item size and the cube root of the remaining capacity of bins, multiplied by the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(item) - np.cbrt(bins)) * np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins == bins.max())\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins) + np.sqrt( np.arange(len(bins)) )\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by modifying the ratio and logarithm operators used in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (np.log(ratios + 1)) / (1 + np.log(ratios))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the remaining capacity of each bin divided by the factorial of the bin number, excluding bins with maximum capacity, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty(len(bins), dtype=float)\\n max_capacity = np.amax(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = (item * (max_capacity - bins[i])) / math.factorial(i)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the cube root of the product of the bin's index and the item size, excluding bins with maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1) * item)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the logarithm of the item size and the cube root of the remaining capacity of bins, multiplied by the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(item) - np.cbrt(bins)) * np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins - item) - np.arange(1, len(bins)+1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins) + np.sqrt( np.arange(len(bins)) )\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by modifying the ratio and logarithm operators used in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (np.log(ratios + 1)) / (1 + np.log(ratios))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the remaining capacity of each bin divided by the factorial of the bin number, excluding bins with maximum capacity, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty(len(bins), dtype=float)\\n max_capacity = np.amax(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = (item * (max_capacity - bins[i])) / math.factorial(i)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins) + np.sqrt( np.arange(len(bins)) )\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by modifying the ratio and logarithm operators used in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (np.log(ratios + 1)) / (1 + np.log(ratios))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the square of the item size and the remaining capacity of each bin plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 - bins + 1)**2\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the square of the item size and the remaining capacity of each bin plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 - bins + 1)**2\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the square of the item size and the remaining capacity of each bin plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 - bins + 1)**2\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of the square of the item size to the remaining capacity of each bin, then subtract the index of the bin from the maximum capacity to prioritize bins with higher remaining capacity while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on the formula\\n scores = (item**2) / remaining_capacity\\n \\n # Subtract the index of the bin from the maximum capacity\\n scores -= (bins.max() - np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on some combination of the bin's remaining capacity and its proximity to the item size.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the inverse of the square of the bin's remaining capacity and the product of the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / np.square(remaining_capacity)) * (np.arange(len(bins)) * item)\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the bin's remaining capacity plus the absolute difference between the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.abs(np.arange(len(bins)) - item)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = item / (np.sum(bins) + np.sqrt(np.arange(1,len(bins)+1)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (np.sum(bins) + np.sqrt(np.arange(1,len(bins)+1)))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio of item size to the remaining capacity and the reciprocal of the bin number, excluding bins with maximum capacity, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item/bins) * (1/(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.int32)\\n max_capacity = np.amax(bins)\\n \\n if item == max_capacity:\\n return scores\\n \\n scores = (max_capacity - bins) - (max_capacity - bins) % item\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the bin's remaining capacity to the inverse of the item size plus the square root of the bin number, and return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (1 / item + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will assign scores to each bin based on the inverse ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and excluding bins with rest capacity equal to the maximum capacity or the item size, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where((bins != bins.max()) & (bins != item), bins / (bins - item), 0)\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Define a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins by considering the remaining capacity of bins and giving higher scores to bins with more space available.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bins_with_capacity = np.nonzero(bins > item)[0]\\n scores[bins_with_capacity] = bins[bins_with_capacity] / (bins[bins_with_capacity] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins == item] = -float('inf')\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] != item:\\n scores[i] = (bins[i] - item) / bins[i]\\n else:\\n scores[i] = -1\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on some combination of the bin's remaining capacity and its proximity to the item size.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the logarithmic function of the bin's remaining capacity and the exponential function of the product of the bin's index and the item size, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_item = np.arange(1, len(bins)+1)\\n scores = np.log(bins) * np.exp(index_item * item)\\n return scores\",\n \"objective\": 0.05463,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the remaining capacity of each bin divided by the square of the bin number plus the square root of the item, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.square(np.arange(len(bins))) + np.sqrt(item))\\n return scores\",\n \"objective\": 0.05504,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"F\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the sum of each bin's remaining capacity and the bin number multiplied by a constant factor, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"F\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will calculate the scores by dividing the maximum bin capacity by the remaining capacity of each bin after assigning the item, and then subtracting the index of each bin multiplied by the logarithm of the remaining capacity, with the intention of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity < 0] = 0\\n scores = (max_capacity / remaining_capacity) - (np.arange(len(bins)) * np.log(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and higher index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins/item\\n scores[bins == item] = np.nan\\n scores[np.isnan(scores)] = -np.inf\\n scores *= (bins != item)\\n scores += np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"F\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the minimum remaining capacity of each bin divided by the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will calculate the scores by dividing the maximum bin capacity by the remaining capacity of each bin after assigning the item, and then subtracting the index of each bin multiplied by the logarithm of the remaining capacity, with the intention of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity < 0] = 0\\n scores = (max_capacity / remaining_capacity) - (np.arange(len(bins)) * np.log(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the square of the item size to the remaining capacity of each bin minus the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item**2) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the product of the logarithm of the ratio of the item size to the remaining capacity of each bin and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then multiplies the scores by the square root of the bin number and returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (item - bins)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the combination of the logarithm of the ratio of the item size to the remaining capacity of each bin and a modified power function of the bin index, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(item / bins) * (np.power(range(len(bins)), 0.5) + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number multiplied by a weight factor, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.log(np.arange(1, len(bins)+1)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the square root of the remaining capacity of each bin, multiplied by the square root of the bin number minus the item, then returns the scores for the bins as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / np.sqrt(bins)) * (np.sqrt(range(1, len(bins)+1)) - item)).astype(int)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the difference between the item size and the remaining capacity of each bin, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the square of the bin's remaining capacity divided by the product of the bin's index and the difference between the item size and the maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins)) + 1\\n difference = bins - item\\n scores = (bins ** 2) / (indices * difference)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of the square of the item size to the remaining capacity of each bin, then subtract the index of the bin from the maximum capacity to prioritize bins with higher remaining capacity while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on the formula\\n scores = (item**2) / remaining_capacity\\n \\n # Subtract the index of the bin from the maximum capacity\\n scores -= (bins.max() - np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on some combination of the bin's remaining capacity and its proximity to the item size.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the inverse of the square of the bin's remaining capacity and the product of the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / np.square(remaining_capacity)) * (np.arange(len(bins)) * item)\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the bin's remaining capacity plus the absolute difference between the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.abs(np.arange(len(bins)) - item)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item)[::-1]\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio of item size to the remaining capacity and the reciprocal of the bin number, excluding bins with maximum capacity, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item/bins) * (1/(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the square of the bin's remaining capacity divided by the product of the bin's index and the sum of the item size and the maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(1, len(bins) + 1)\\n max_capacity = max(bins)\\n remaining_capacity = max_capacity - bins\\n \\n scores = (remaining_capacity**2) / (index * (item + max_capacity))\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.int32)\\n max_capacity = np.amax(bins)\\n \\n if item == max_capacity:\\n return scores\\n \\n scores = (max_capacity - bins) - (max_capacity - bins) % item\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Scoring bins based on a combination of remaining capacity and proximity to the item size.}\\n\\n{New algorithm: The score function will calculate scores for each bin based on the bin's remaining capacity normalized by the item size divided by the bin number, aiming to prioritize bins with higher capacity and lower index for assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (bins / item) / (indices + 1)\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the square of the bin's remaining capacity divided by the product of the bin's index and the difference between the item size and the maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins)) + 1\\n difference = bins - item\\n scores = (bins ** 2) / (indices * difference)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of the square of the item size to the remaining capacity of each bin, then subtract the index of the bin from the maximum capacity to prioritize bins with higher remaining capacity while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on the formula\\n scores = (item**2) / remaining_capacity\\n \\n # Subtract the index of the bin from the maximum capacity\\n scores -= (bins.max() - np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of their remaining capacity, the item size, and a penalty for bins with maximum capacity, in order to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, -np.inf, 0)\\n scores = bins / max_capacity + item / bins + penalty\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the floor division of the item size by the remaining capacity of each bin plus the reciprocal of the square root of the bin number, excluding bins with maximum capacity, and return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.floor_divide(item, bins[:-1]) + 1 / np.sqrt(np.arange(1, len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the bin's remaining capacity plus the absolute difference between the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.abs(np.arange(len(bins)) - item)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item)[::-1]\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's remaining capacity divided by the item size and multiplied by the inverse of the bin's index plus one, ensuring bins with lower indices and higher remaining capacities are prioritized, leading to efficient bin assignment and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate scores for each bin\\n scores = bins / item * (1 / (np.arange(len(bins)) + 1))\\n \\n # Set scores of bins with maximum capacity to 0\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio of item size to the remaining capacity and the reciprocal of the bin number, excluding bins with maximum capacity, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item/bins) * (1/(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the logarithm of the sum of the bin's remaining capacity and the item size, dividing it by the square root of the bin index, aiming to balance bin usage and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.log(remaining_capacity + item) / np.sqrt(np.arange(1, len(bins)+1))).tolist()\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the square of the bin's remaining capacity divided by the product of the bin's index and the sum of the item size and the maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(1, len(bins) + 1)\\n max_capacity = max(bins)\\n remaining_capacity = max_capacity - bins\\n \\n scores = (remaining_capacity**2) / (index * (item + max_capacity))\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the square of the bin's remaining capacity divided by the product of the bin's index and the difference between the item size and the maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins)) + 1\\n difference = bins - item\\n scores = (bins ** 2) / (indices * difference)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of the square of the item size to the remaining capacity of each bin, then subtract the index of the bin from the maximum capacity to prioritize bins with higher remaining capacity while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on the formula\\n scores = (item**2) / remaining_capacity\\n \\n # Subtract the index of the bin from the maximum capacity\\n scores -= (bins.max() - np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of their remaining capacity, the item size, and a penalty for bins with maximum capacity, in order to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, -np.inf, 0)\\n scores = bins / max_capacity + item / bins + penalty\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the floor division of the item size by the remaining capacity of each bin plus the reciprocal of the square root of the bin number, excluding bins with maximum capacity, and return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.floor_divide(item, bins[:-1]) + 1 / np.sqrt(np.arange(1, len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array. In addition, it penalizes bins that have a remaining capacity of zero by subtracting a constant factor from their scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this value as needed\\n \\n # Calculate the scores for each bin\\n scores = 1 / (bins + 1) + np.sqrt(np.arange(len(bins)) + 1)\\n \\n # Penalize bins with zero remaining capacity\\n scores[bins == 0] -= constant_factor\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the bin's remaining capacity plus the absolute difference between the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.abs(np.arange(len(bins)) - item)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item)[::-1]\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's remaining capacity divided by the item size and multiplied by the inverse of the bin's index plus one, ensuring bins with lower indices and higher remaining capacities are prioritized, leading to efficient bin assignment and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate scores for each bin\\n scores = bins / item * (1 / (np.arange(len(bins)) + 1))\\n \\n # Set scores of bins with maximum capacity to 0\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio of item size to the remaining capacity and the reciprocal of the bin number, excluding bins with maximum capacity, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item/bins) * (1/(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the logarithm of the sum of the bin's remaining capacity and the item size, dividing it by the square root of the bin index, aiming to balance bin usage and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.log(remaining_capacity + item) / np.sqrt(np.arange(1, len(bins)+1))).tolist()\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the square of the bin's remaining capacity divided by the product of the bin's index and the difference between the item size and the maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins)) + 1\\n difference = bins - item\\n scores = (bins ** 2) / (indices * difference)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of the square of the item size to the remaining capacity of each bin, then subtract the index of the bin from the maximum capacity to prioritize bins with higher remaining capacity while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on the formula\\n scores = (item**2) / remaining_capacity\\n \\n # Subtract the index of the bin from the maximum capacity\\n scores -= (bins.max() - np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of their remaining capacity, the item size, and a penalty for bins with maximum capacity, in order to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, -np.inf, 0)\\n scores = bins / max_capacity + item / bins + penalty\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the remaining capacity of the bin divided by the square root of the product of the bin's index and the maximum capacity, in order to consider the prioritization of bins based on remaining capacity, while also considering their index and maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n max_capacity = np.max(bins)\\n scores = bins / (index * max_capacity) ** 0.5\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the floor division of the item size by the remaining capacity of each bin plus the reciprocal of the square root of the bin number, excluding bins with maximum capacity, and return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.floor_divide(item, bins[:-1]) + 1 / np.sqrt(np.arange(1, len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array. In addition, it penalizes bins that have a remaining capacity of zero by subtracting a constant factor from their scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this value as needed\\n \\n # Calculate the scores for each bin\\n scores = 1 / (bins + 1) + np.sqrt(np.arange(len(bins)) + 1)\\n \\n # Penalize bins with zero remaining capacity\\n scores[bins == 0] -= constant_factor\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the bin's remaining capacity plus the absolute difference between the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.abs(np.arange(len(bins)) - item)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item)[::-1]\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's remaining capacity divided by the item size and multiplied by the inverse of the bin's index plus one, ensuring bins with lower indices and higher remaining capacities are prioritized, leading to efficient bin assignment and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate scores for each bin\\n scores = bins / item * (1 / (np.arange(len(bins)) + 1))\\n \\n # Set scores of bins with maximum capacity to 0\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio of item size to the remaining capacity and the reciprocal of the bin number, excluding bins with maximum capacity, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item/bins) * (1/(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the square of the bin's remaining capacity divided by the product of the bin's index and the difference between the item size and the maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins)) + 1\\n difference = bins - item\\n scores = (bins ** 2) / (indices * difference)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of the square of the item size to the remaining capacity of each bin, then subtract the index of the bin from the maximum capacity to prioritize bins with higher remaining capacity while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on the formula\\n scores = (item**2) / remaining_capacity\\n \\n # Subtract the index of the bin from the maximum capacity\\n scores -= (bins.max() - np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of their remaining capacity, the item size, and a penalty for bins with maximum capacity, in order to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, -np.inf, 0)\\n scores = bins / max_capacity + item / bins + penalty\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the floor division of the item size by the remaining capacity of each bin plus the reciprocal of the square root of the bin number, excluding bins with maximum capacity, and return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.floor_divide(item, bins[:-1]) + 1 / np.sqrt(np.arange(1, len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square root of the bin's index, and the square of the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = ((max_capacity / bins) + np.sqrt(np.arange(len(bins))) + (item**2 / max_capacity**2)) ** -1\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array. In addition, it penalizes bins that have a remaining capacity of zero by subtracting a constant factor from their scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this value as needed\\n \\n # Calculate the scores for each bin\\n scores = 1 / (bins + 1) + np.sqrt(np.arange(len(bins)) + 1)\\n \\n # Penalize bins with zero remaining capacity\\n scores[bins == 0] -= constant_factor\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / item + np.arange(len(bins)) + np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the bin's remaining capacity plus the absolute difference between the bin's index and the item size to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.abs(np.arange(len(bins)) - item)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the remaining capacity to the item size, prioritizing bins with higher ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item)[::-1]\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of the square of the item size to the remaining capacity of each bin, then subtract the index of the bin from the maximum capacity to prioritize bins with higher remaining capacity while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on the formula\\n scores = (item**2) / remaining_capacity\\n \\n # Subtract the index of the bin from the maximum capacity\\n scores -= (bins.max() - np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of their remaining capacity, the item size, and a penalty for bins with maximum capacity, in order to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, -np.inf, 0)\\n scores = bins / max_capacity + item / bins + penalty\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the cube root of the product of the bin's index and the item size, excluding bins with maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1) * item)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the floor division of the item size by the remaining capacity of each bin plus the reciprocal of the square root of the bin number, excluding bins with maximum capacity, and return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.floor_divide(item, bins[:-1]) + 1 / np.sqrt(np.arange(1, len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = item + 1 / (bins - item) + np.abs(np.arange(len(bins)) - np.max(bins) / item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item + 1 / (bins - item) + np.abs(np.arange(len(bins)) - np.max(bins) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square root of the bin's index, and the square of the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = ((max_capacity / bins) + np.sqrt(np.arange(len(bins))) + (item**2 / max_capacity**2)) ** -1\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array. In addition, it penalizes bins that have a remaining capacity of zero by subtracting a constant factor from their scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this value as needed\\n \\n # Calculate the scores for each bin\\n scores = 1 / (bins + 1) + np.sqrt(np.arange(len(bins)) + 1)\\n \\n # Penalize bins with zero remaining capacity\\n scores[bins == 0] -= constant_factor\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n sorted_indices = np.argsort(bins)\\n \\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return scores\\n \\n for i in range(len(sorted_indices)):\\n bin_index = sorted_indices[i]\\n bin_capacity = bins[bin_index]\\n \\n if bin_capacity == max_capacity:\\n break\\n \\n if bin_capacity >= item:\\n scores[bin_index] = bin_capacity - item\\n break\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = 1 / remaining_capacity + np.sqrt(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the bin index divided by the item size, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n # If the rest capacity equals the maximum capacity,\\n # assign a very low score to this bin to avoid using it\\n scores[i] = -np.inf\\n else:\\n scores[i] = (1 / (bins[i] - item)) + (i / item) + (item / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, prioritizing bins with lower ratios and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / (bins - item)\\n indices = np.arange(len(bins))\\n scores = ratios + indices\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the item size to the product of the bin's index and its remaining capacity, excluding bins with maximum capacity, in order to prioritize bins with lower remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n scores = item / (indices + 1) / remaining_capacities\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores by taking the sum of the bin capacities divided by the remaining capacity of each bin after assigning the item, and then adding the index of each bin multiplied by the logarithm of the maximum bin capacity, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (bins / remaining_capacities) + (np.arange(len(bins)) * np.log(np.max(bins)))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the inverse of the remaining capacity of each bin divided by the square root of the bin number plus a constant, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins.astype(float) - item)) / np.sqrt(np.arange(1, len(bins) + 1)) + 1\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin's remaining capacity, the square of the bin's index, and the item size divided by the maximum capacity, to optimize bin usage while assigning the item to bins with higher score and minimum number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Calculate scores for each bin\\n scores = (1 / remaining_capacity) * (np.square(np.arange(len(bins))) * (item / max_capacity))\\n \\n # Set score of bins with maximum capacity as 0\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on a combination of the ratio of the logarithm of the item size to the cube root of the remaining capacity of each bin and the square root of the bin number minus the square root of the item, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.cbrt(bins) + np.sqrt(np.arange(1, len(bins)+1)) - np.sqrt(item)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to each bin based on the ratio of item size to the square of each bin's rest capacity, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins**2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the remaining capacity of each bin plus the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins + np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity of each bin plus the square root of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins) + np.sqrt( np.arange(len(bins)) )\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity relative to the item size.}\\n\\n{New algorithm: Assign scores to bins based on the ratio of the item size to the sum of each bin's remaining capacity and the logarithm of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.log(np.arange(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the logarithm of the item size to the remaining capacity of each bin plus the square root of the bin number, then return the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / np.log(bins) + np.sqrt(np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by modifying the ratio and logarithm operators used in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (np.log(ratios + 1)) / (1 + np.log(ratios))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common idea in the provided algorithms is to assign scores to bins based on some combination of the bin's remaining capacity and its relationship to the item size.}\\n\\n{New algorithm: Assign scores to each bin based on the logarithm of the bin's remaining capacity divided by the product of the square of the difference between the item size and the maximum capacity of the bins plus the bin's index, to prioritize bins with higher remaining capacity while considering the item size and the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((item - bins)**2 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the remaining capacity of each bin divided by the factorial of the bin number, excluding bins with maximum capacity, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty(len(bins), dtype=float)\\n max_capacity = np.amax(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = (item * (max_capacity - bins[i])) / math.factorial(i)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the cube root of the product of the bin's index and the item size, excluding bins with maximum capacity, in order to prioritize bins with higher remaining capacity while considering the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1) * item)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse of the item size minus the remaining capacity of each bin multiplied by the logarithm of the bin number, then returns the scores for the bins for assignment as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item - bins)) * np.log(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = item + 1 / (bins - item) + np.abs(np.arange(len(bins)) - np.max(bins) / item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item + 1 / (bins - item) + np.abs(np.arange(len(bins)) - np.max(bins) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the inverse of the square of the rest capacity, minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (1 / (bins ** 2)))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to the bins by dividing the inverse of the rest capacity by the difference between the item size and the rest capacity, taking into account the proximity to the item size and the inverse bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n used_bins = np.count_nonzero(bins != max_capacity)\\n\\n if used_bins == len(bins):\\n return scores\\n\\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n score = (1 / (max_capacity - bins[i])) / (item - bins[i])\\n scores[i] = score + (1 / (i + 1))\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its rest capacity and/or the ratio of item size to capacity, and then assign the item to the bin with the maximum score.}\\n\\n{New algorithm:}\\n\\n{1. Calculate the score for each bin based on the logarithm of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the reciprocal of its rest capacity and the square of the item size, using a weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.reciprocal(bins) * item**2\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the ratio of the item size to the remaining capacity, taking into account the inverse of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins, but additionally considers the number of items already assigned to each bin to adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = bin_capacity - item - np.sum(bins[:i])\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size, prioritizing bins with higher ratios and lower indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the bin's rest capacity, squared, and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) ** 2 * np.arange(len(bins))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * np.log(bins) / (bins - item)\\n scores[bins == item] = -np.inf\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, taking into account a weighted average using the reciprocal of the bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] != item:\\n ratio = item / (bins[i] - item)\\n scores[i] = ratio / (i+1)\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating the scores based on the rest capacity of the bins and considering factors such as item size, proximity to item size, and inverse bin number.}\\n\\n{New algorithm description: The new algorithm assigns scores to the bins based on the product of the item size and the inverse of the rest capacity, considering the proximity to the item size and the inverse bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inverse_bin_number = 1 / np.arange(1, len(bins) + 1)\\n proximity_to_item_size = np.abs(bins - item)\\n\\n scores = item * inverse_bin_number * proximity_to_item_size / bins\\n scores[bins == np.max(bins)] = 0 # Setting score to 0 for bins with maximum capacity\\n\\n return scores\",\n \"objective\": 0.06057,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the ratio of item size to each bin's rest capacity, and calculate the score for each bin based on the ratio and the condition of the rest capacity. If the ratio is greater than a threshold, assign a very low score to the bin. If the rest capacity of the bin is equal to the maximum capacity, assign a very low score to the bin. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n threshold = 0.5\\n scores = np.zeros_like(bins, dtype=np.float64)\\n \\n for i in range(len(bins)):\\n ratio = item / bins[i]\\n if ratio > threshold or bins[i] == max_capacity:\\n scores[i] = -1e9 # Assign a very low score\\n else:\\n scores[i] = ratio\\n \\n return scores\",\n \"objective\": 0.06399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using the remaining capacity and considering penalties for bins at maximum capacity, the new algorithm calculates the scores as the ratio between the item size and the remaining capacity, giving higher weights to bins with lower indices and aiming for an even distribution of items across bins to minimize their usage.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining_cap = bins - item\\n max_cap = np.max(bins)\\n penalty = (remaining_cap == max_cap).astype(np.float32)\\n idx = np.arange(len(bins))\\n weights = (1 - penalty) / (1 + idx)\\n scores = item / remaining_cap * weights\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with lower indices, aiming to prioritize bins with higher indices and reduce the usage of low-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = bins.shape[0]\\n scores = np.zeros(n)\\n max_capacity = np.max(bins)\\n \\n for i in range(n):\\n capacity_ratio = item / (bins[i] - item) if bins[i] != max_capacity else 0\\n index_penalty = 1 / (i + 1)\\n scores[i] = capacity_ratio + index_penalty\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio between item size and remaining capacity, penalties for bins at maximum capacity, and a weighted average considering the reciprocal of the bin number and the square of the item size, aiming for an even distribution of items and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(remaining_capacity)\\n \\n # Calculate ratio between item size and remaining capacity\\n ratio = item / remaining_capacity\\n \\n # Calculate penalties for bins at maximum capacity\\n penalties = np.where(remaining_capacity == max_capacity, -np.inf, 0)\\n \\n # Calculate weighted average\\n bin_number_weights = 1 / np.arange(1, len(bins)+1)\\n item_size_weights = item**2\\n \\n weighted_average = (bin_number_weights + item_size_weights) / 2\\n \\n # Calculate scores for bins\\n scores = ratio + penalties + weighted_average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's normalized load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment, with the added modification of penalizing bins that are at maximum capacity by setting their scores to -np.inf.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratios = (bins - item) / bins\\n load_ratios[load_ratios == 1] = -np.inf\\n scores = (bins - item) / (bins * load_ratios)\\n scores[scores == -np.inf] = np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the ratio between the item size and the remaining capacity of each bin, weighted by factors such as the difference between the bin capacity and item size or the bin load ratio.}\\n\\n{New algorithm: The score function assigns scores to each bin by considering the maximum factor between the ratio of the item size to the remaining capacity and the ratio of the bin load to the bin capacity, aiming to balance the distribution of items while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = np.maximum(item / bins, bins / np.max(bins))\\n scores = np.where(bins == np.max(bins), 0, ratios)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using the remaining capacity and considering penalties for bins at maximum capacity, the new algorithm calculates the scores as the ratio between the item size and the remaining capacity, giving higher weights to bins with lower indices and aiming for an even distribution of items across bins to minimize their usage.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining_cap = bins - item\\n max_cap = np.max(bins)\\n penalty = (remaining_cap == max_cap).astype(np.float32)\\n idx = np.arange(len(bins))\\n weights = (1 - penalty) / (1 + idx)\\n scores = item / remaining_cap * weights\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with lower indices, aiming to prioritize bins with higher indices and reduce the usage of low-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = bins.shape[0]\\n scores = np.zeros(n)\\n max_capacity = np.max(bins)\\n \\n for i in range(n):\\n capacity_ratio = item / (bins[i] - item) if bins[i] != max_capacity else 0\\n index_penalty = 1 / (i + 1)\\n scores[i] = capacity_ratio + index_penalty\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio between item size and remaining capacity, penalties for bins at maximum capacity, and a weighted average considering the reciprocal of the bin number and the square of the item size, aiming for an even distribution of items and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(remaining_capacity)\\n \\n # Calculate ratio between item size and remaining capacity\\n ratio = item / remaining_capacity\\n \\n # Calculate penalties for bins at maximum capacity\\n penalties = np.where(remaining_capacity == max_capacity, -np.inf, 0)\\n \\n # Calculate weighted average\\n bin_number_weights = 1 / np.arange(1, len(bins)+1)\\n item_size_weights = item**2\\n \\n weighted_average = (bin_number_weights + item_size_weights) / 2\\n \\n # Calculate scores for bins\\n scores = ratio + penalties + weighted_average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the ratio between the item size and the remaining capacity of each bin, weighted by factors such as the difference between the bin capacity and item size or the bin load ratio.}\\n\\n{New algorithm: The score function assigns scores to each bin by considering the maximum factor between the ratio of the item size to the remaining capacity and the ratio of the bin load to the bin capacity, aiming to balance the distribution of items while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = np.maximum(item / bins, bins / np.max(bins))\\n scores = np.where(bins == np.max(bins), 0, ratios)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with lower indices, aiming to prioritize bins with higher indices and reduce the usage of low-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = bins.shape[0]\\n scores = np.zeros(n)\\n max_capacity = np.max(bins)\\n \\n for i in range(n):\\n capacity_ratio = item / (bins[i] - item) if bins[i] != max_capacity else 0\\n index_penalty = 1 / (i + 1)\\n scores[i] = capacity_ratio + index_penalty\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on a combination of the item's size and the bin's remaining capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by dividing the item's size by the sum of the bin's remaining capacity and the square root of the bin number, aiming to prioritize bins with larger remaining capacities while considering the bin's position in the order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins) + 1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with lower indices, aiming to prioritize bins with higher indices and reduce the usage of low-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = bins.shape[0]\\n scores = np.zeros(n)\\n max_capacity = np.max(bins)\\n \\n for i in range(n):\\n capacity_ratio = item / (bins[i] - item) if bins[i] != max_capacity else 0\\n index_penalty = 1 / (i + 1)\\n scores[i] = capacity_ratio + index_penalty\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on a combination of the item's size and the bin's remaining capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by dividing the item's size by the sum of the bin's remaining capacity and the square root of the bin number, aiming to prioritize bins with larger remaining capacities while considering the bin's position in the order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins) + 1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on a combination of the item's size and the bin's remaining capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by dividing the item's size by the sum of the bin's remaining capacity and the square root of the bin number, aiming to prioritize bins with larger remaining capacities while considering the bin's position in the order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins) + 1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average, and consider a penalty term for bins that have reached their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n bin_numbers = np.arange(len(bins))\\n \\n scores = (inverse_rest_capacity + bin_numbers / item) / 2\\n \\n penalty = max_capacity - bins\\n scores[penalty == 0] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average, and consider a penalty term for bins that have reached their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n bin_numbers = np.arange(len(bins))\\n \\n scores = (inverse_rest_capacity + bin_numbers / item) / 2\\n \\n penalty = max_capacity - bins\\n scores[penalty == 0] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average, and consider a penalty term for bins that have reached their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n bin_numbers = np.arange(len(bins))\\n \\n scores = (inverse_rest_capacity + bin_numbers / item) / 2\\n \\n penalty = max_capacity - bins\\n scores[penalty == 0] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity divided by the product of the bin capacity and the bin load ratio, with the aim of maximizing the usage of bins and minimizing the imbalance in distribution of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_load_ratio = bins / np.max(bins) # Calculate bin load ratio\\n scores = (item - bins) / (bins * bin_load_ratio) # Calculate scores\\n scores[bins == np.max(bins)] = -np.inf # Set score to -inf for bins with maximum capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average, and consider a penalty term for bins that have reached their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n bin_numbers = np.arange(len(bins))\\n \\n scores = (inverse_rest_capacity + bin_numbers / item) / 2\\n \\n penalty = max_capacity - bins\\n scores[penalty == 0] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin, while introducing a penalty term based on the square of the square root of the bin number, aiming to prioritize bins with smaller numbers and larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins)+1)\\n bin_capacities = bins - item\\n num_items_in_bin = np.zeros(len(bins))\\n \\n scores = (item / bin_capacities) * np.sqrt(bin_nums) - np.sqrt(bin_nums)**2\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(bins-item) + np.cbrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"C\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - bins[i]) / (max_capacity - item)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the scoring methods used in the existing algorithms, the new algorithm will calculate the scores for each bin based on the ratio between the item size and the remaining capacity, taking into account a weighted average using the reciprocal of the bin number and the square of the item size, as well as considering the number of items already assigned to each bin and aiming for an even distribution across all bins, ultimately minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.reciprocal(np.arange(1, len(bins)+1))\\n item_size_sq = np.square(item)\\n remaining_capacity = bins - item\\n \\n scores = (item_size_sq / remaining_capacity) * weights\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its rest capacity and/or the ratio of item size to capacity, and then assign the item to the bin with the maximum score.}\\n\\n{New algorithm:}\\n\\n{1. Calculate the score for each bin based on the logarithm of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the reciprocal of its rest capacity and the square of the item size, using a weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.reciprocal(bins) * item**2\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the ratio of the item size to the remaining capacity, taking into account the inverse of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins, but additionally considers the number of items already assigned to each bin to adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = bin_capacity - item - np.sum(bins[:i])\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on the product of the item size, the inverse of the bin capacity, and a logarithmic function of the bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) \\n max_capacity = np.amax(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = item * (1 / bins[i]) * np.log(i+1)\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size, prioritizing bins with higher ratios and lower indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the sum of the bin's rest capacity and the item size squared, using the inverse of the bin number squared as the weight.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.square(np.arange(1, len(bins)+1))\\n scores = bins + np.square(item) * weights\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the bin's rest capacity, squared, and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) ** 2 * np.arange(len(bins))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * np.log(bins) / (bins - item)\\n scores[bins == item] = -np.inf\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, taking into account a weighted average using the reciprocal of the bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] != item:\\n ratio = item / (bins[i] - item)\\n scores[i] = ratio / (i+1)\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the remaining capacity of the bin, using a weighted average determined by the inverse of the bin number squared, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == item:\\n scores[i] = -np.inf # bin already full, assign lowest score\\n else:\\n scores[i] = item / (bin_capacity - item)\\n \\n weights = 1 / np.arange(1, len(bins) + 1)**2\\n scores = np.multiply(scores, weights)\\n \\n return scores\",\n \"objective\": 0.05192,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity, with a penalty for bins with maximum capacity, and the amount of unused space in the remaining bins, to further minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n # Calculate the scores based on remaining capacity and unused space\\n scores = remaining_capacity + (max_capacity - bins) * (remaining_capacity > 0)\\n \\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average, and consider a penalty term for bins that have reached their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n bin_numbers = np.arange(len(bins))\\n \\n scores = (inverse_rest_capacity + bin_numbers / item) / 2\\n \\n penalty = max_capacity - bins\\n scores[penalty == 0] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function assigns scores to each bin by dividing the item size by the difference between the bin's capacity and the item's size, with a penalty factor based on the position of the bin, aiming to prioritize bins with larger remaining capacities and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the quotient of the item size and the bin's excess capacity, multiplied by a constant factor derived from the bin's load ratio, aiming to optimize the distribution of items and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin, while introducing a penalty term based on the square of the square root of the bin number, aiming to prioritize bins with smaller numbers and larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins)+1)\\n bin_capacities = bins - item\\n num_items_in_bin = np.zeros(len(bins))\\n \\n scores = (item / bin_capacities) * np.sqrt(bin_nums) - np.sqrt(bin_nums)**2\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the item size and the cube of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and cube of bin number\\n scores = item / capacities + bin_nums**3\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n bin_nums = np.arange(1, len(bins) + 1)\\n capacities = bins - item\\n\\n scores = item / capacities + bin_nums**3\\n\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average, and consider a penalty term for bins that have reached their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n bin_numbers = np.arange(len(bins))\\n \\n scores = (inverse_rest_capacity + bin_numbers / item) / 2\\n \\n penalty = max_capacity - bins\\n scores[penalty == 0] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function assigns scores to each bin by dividing the item size by the difference between the bin's capacity and the item's size, with a penalty factor based on the position of the bin, aiming to prioritize bins with larger remaining capacities and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity divided by the item and a constant factor multiplied by the bin number, using a weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) + (0.1 * np.arange(len(bins)))\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of remaining capacity to item size, adjusted by a factor that considers the bin number and load ratio, aiming to distribute items effectively among bins and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / item\\n factor = np.arange(1, len(bins) + 1) / len(bins) * (1 - ratio)\\n scores = ratio * factor\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to prioritize the bins with larger capacity and lower load ratio for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratio = bins / np.max(bins)\\n scores = (item - bins) / (bins * load_ratio)\\n scores[np.where(bins == np.max(bins))] = -np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the item size and the cube of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and cube of bin number\\n scores = item / capacities + bin_nums**3\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n bin_nums = np.arange(1, len(bins) + 1)\\n capacities = bins - item\\n\\n scores = item / capacities + bin_nums**3\\n\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.\\n2. Sort the scores in descending order.\\n3. Assign the item to the bin with the highest score if its rest capacity is not equal to the maximum capacity.\\n4. If all bins have rest capacity equal to the maximum capacity, assign the item to the first bin.\\n5. Repeat steps 1-4 for all items until all items are assigned.\\n6. Count the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (1 / (bins - item)) + (np.arange(len(bins)) / item)\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function assigns scores to each bin by dividing the item size by the difference between the bin's capacity and the item's size, with a penalty factor based on the position of the bin, aiming to prioritize bins with larger remaining capacities and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score is calculated by dividing the item size by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, np.sum(bins)) * np.multiply(np.subtract(item, bins), np.arange(len(bins), 0, -1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity divided by the item and a constant factor multiplied by the bin number, using a weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) + (0.1 * np.arange(len(bins)))\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of remaining capacity to item size, adjusted by a factor that considers the bin number and load ratio, aiming to distribute items effectively among bins and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / item\\n factor = np.arange(1, len(bins) + 1) / len(bins) * (1 - ratio)\\n scores = ratio * factor\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to prioritize the bins with larger capacity and lower load ratio for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratio = bins / np.max(bins)\\n scores = (item - bins) / (bins * load_ratio)\\n scores[np.where(bins == np.max(bins))] = -np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the item size and the cube of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and cube of bin number\\n scores = item / capacities + bin_nums**3\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n bin_nums = np.arange(1, len(bins) + 1)\\n capacities = bins - item\\n\\n scores = item / capacities + bin_nums**3\\n\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.\\n2. Sort the scores in descending order.\\n3. Assign the item to the bin with the highest score if its rest capacity is not equal to the maximum capacity.\\n4. If all bins have rest capacity equal to the maximum capacity, assign the item to the first bin.\\n5. Repeat steps 1-4 for all items until all items are assigned.\\n6. Count the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (1 / (bins - item)) + (np.arange(len(bins)) / item)\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function assigns scores to each bin by dividing the item size by the difference between the bin's capacity and the item's size, with a penalty factor based on the position of the bin, aiming to prioritize bins with larger remaining capacities and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the item size divided by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index; the main steps involve calculating the new scores using modified parameter settings and then assigning the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / np.sum(bins)) * (item - bins) * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity divided by the item and a constant factor multiplied by the bin number, using a weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) + (0.1 * np.arange(len(bins)))\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of remaining capacity to item size, adjusted by a factor that considers the bin number and load ratio, aiming to distribute items effectively among bins and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / item\\n factor = np.arange(1, len(bins) + 1) / len(bins) * (1 - ratio)\\n scores = ratio * factor\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to prioritize the bins with larger capacity and lower load ratio for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratio = bins / np.max(bins)\\n scores = (item - bins) / (bins * load_ratio)\\n scores[np.where(bins == np.max(bins))] = -np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the item size and the cube of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and cube of bin number\\n scores = item / capacities + bin_nums**3\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n bin_nums = np.arange(1, len(bins) + 1)\\n capacities = bins - item\\n\\n scores = item / capacities + bin_nums**3\\n\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.\\n2. Sort the scores in descending order.\\n3. Assign the item to the bin with the highest score if its rest capacity is not equal to the maximum capacity.\\n4. If all bins have rest capacity equal to the maximum capacity, assign the item to the first bin.\\n5. Repeat steps 1-4 for all items until all items are assigned.\\n6. Count the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (1 / (bins - item)) + (np.arange(len(bins)) / item)\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function assigns scores to each bin by dividing the item size by the difference between the bin's capacity and the item's size, with a penalty factor based on the position of the bin, aiming to prioritize bins with larger remaining capacities and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the item size divided by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index; the main steps involve calculating the new scores using modified parameter settings and then assigning the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / np.sum(bins)) * (item - bins) * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity divided by the item and a constant factor multiplied by the bin number, using a weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) + (0.1 * np.arange(len(bins)))\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of remaining capacity to item size, adjusted by a factor that considers the bin number and load ratio, aiming to distribute items effectively among bins and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / item\\n factor = np.arange(1, len(bins) + 1) / len(bins) * (1 - ratio)\\n scores = ratio * factor\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to prioritize the bins with larger capacity and lower load ratio for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratio = bins / np.max(bins)\\n scores = (item - bins) / (bins * load_ratio)\\n scores[np.where(bins == np.max(bins))] = -np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number, using a weighted average with different weights for each factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.array([1 / (i + 1) for i in range(len(bins))]) # Weights for each bin number\\n \\n rest_capacity = bins - item\\n rest_capacity[rest_capacity == max(bins)] = 0 # If rest capacity equals maximum capacity, set it to 0\\n \\n inverse_rest_capacity = 1 / rest_capacity\\n scores = np.average([inverse_rest_capacity, weights], axis=0, weights=[0.7, 0.3]) # Weighted average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the item size and the bin's remaining capacity, while considering a penalty for bins with lower indices and a bonus for bins with larger remaining capacities, aiming to balance capacity utilization and prioritize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n\\n # Calculate the score based on the ratio between item size and remaining capacity\\n scores = item / remaining_capacities\\n\\n # Apply a penalty for bins with lower indices\\n scores -= indices\\n\\n # Apply a bonus for bins with larger remaining capacities\\n scores += remaining_capacities\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the item size and the cube of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and cube of bin number\\n scores = item / capacities + bin_nums**3\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n bin_nums = np.arange(1, len(bins) + 1)\\n capacities = bins - item\\n\\n scores = item / capacities + bin_nums**3\\n\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the score for each bin based on the inverse of the rest capacity and the cube root of the bin number, using a weighted average.\\n2. Return the scores for the bins for assignment.}\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n cube_root_bin_number = np.cbrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, cube_root_bin_number)), axis=1)\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n cube_root_bin_number = np.cbrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, cube_root_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.\\n2. Sort the scores in descending order.\\n3. Assign the item to the bin with the highest score if its rest capacity is not equal to the maximum capacity.\\n4. If all bins have rest capacity equal to the maximum capacity, assign the item to the first bin.\\n5. Repeat steps 1-4 for all items until all items are assigned.\\n6. Count the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (1 / (bins - item)) + (np.arange(len(bins)) / item)\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average, and subtract the natural logarithm of the bin index multiplied by the remaining capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = (1 / remaining_capacity) * np.sqrt(bin_indices) - np.log(bin_indices) * (remaining_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function assigns scores to each bin by dividing the item size by the difference between the bin's capacity and the item's size, with a penalty factor based on the position of the bin, aiming to prioritize bins with larger remaining capacities and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the item size divided by the sum of the rest capacities, multiplied by the difference between the item size and the rest capacity, multiplied by a decreasing index; the main steps involve calculating the new scores using modified parameter settings and then assigning the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / np.sum(bins)) * (item - bins) * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. Calculate the score for each bin based on the inverse of the rest capacity divided by the item and a constant factor multiplied by the bin number, using a weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) + (0.1 * np.arange(len(bins)))\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the difference between the item and the rest capacity, using the negative reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1 / np.arange(1, len(bins) + 1)) * (bins - item)\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of remaining capacity to item size, adjusted by a factor that considers the bin number and load ratio, aiming to distribute items effectively among bins and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / item\\n factor = np.arange(1, len(bins) + 1) / len(bins) * (1 - ratio)\\n scores = ratio * factor\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity, dividing it by the product of the bin capacity and the bin's square root of the load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final score will also consider a penalty factor for bins with higher indices to encourage the utilization of lower-indexed bins, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the load ratios for each bin\\n load_ratios = 1 - bins / np.max(bins)\\n \\n # Calculate the scores for each bin\\n scores = (bins - item) / (item * load_ratios)\\n \\n # Set scores of bins with rest capacity equal to maximum capacity to -inf\\n scores[bins == np.max(bins)] = -np.inf\\n \\n # Add penalty factor for higher-indexed bins\\n penalty_factor = np.arange(len(bins))\\n scores -= penalty_factor\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to prioritize the bins with larger capacity and lower load ratio for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratio = bins / np.max(bins)\\n scores = (item - bins) / (bins * load_ratio)\\n scores[np.where(bins == np.max(bins))] = -np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n for i, capacity in enumerate(bins):\\n if capacity == item:\\n scores[i] = -1\\n elif capacity > item:\\n scores[i] = item - capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the scoring methods used in the existing algorithms, the new algorithm will calculate the scores for each bin based on the ratio between the item size and the remaining capacity, taking into account a weighted average using the reciprocal of the bin number and the square of the item size, as well as considering the number of items already assigned to each bin and aiming for an even distribution across all bins, ultimately minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.reciprocal(np.arange(1, len(bins)+1))\\n item_size_sq = np.square(item)\\n remaining_capacity = bins - item\\n \\n scores = (item_size_sq / remaining_capacity) * weights\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its rest capacity and/or the ratio of item size to capacity, and then assign the item to the bin with the maximum score.}\\n\\n{New algorithm:}\\n\\n{1. Calculate the score for each bin based on the logarithm of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the product of its rest capacity and the logarithm of the item size, using a weighted average.\\n2. Sort the bins in descending order of their scores.\\n3. Assign the item to the first bin in the sorted list that has a rest capacity smaller than the maximum capacity and update its rest capacity accordingly.\\n4. Repeat steps 2 and 3 until all items have been assigned to bins.\\n5. Calculate the number of used bins as the total number of bins minus the number of bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)).mean()\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the remaining capacity to the item's value, with higher weights assigned to bins with lower indices, and assigns the item to the bin with the maximum score, minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacity_ratio = bins / item\\n indices = np.arange(num_bins)\\n weights = 1 / (indices + 1) # Higher weights assigned to bins with lower indices\\n\\n scores = capacity_ratio * weights\\n scores[bins == np.max(bins)] = 0 # Exclude bins with maximum capacity from being used\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the ratio of the item size to the remaining capacity, taking into account the inverse of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the score for each bin based on the sum of the bin's rest capacity and the item size cubed, using the inverse of the square root of the bin number as the weight.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.sqrt(np.arange(1, len(bins)+1))\\n rest_capacity = bins - item\\n scores = rest_capacity + item**3 * weights\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins, but additionally considers the number of items already assigned to each bin to adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = bin_capacity - item - np.sum(bins[:i])\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on the product of the item size, the inverse of the bin capacity, and a logarithmic function of the bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) \\n max_capacity = np.amax(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = item * (1 / bins[i]) * np.log(i+1)\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe common backbone idea in the provided algorithms is to calculate scores for each bin based on some ratio or difference involving the remaining capacity and the item size, and then assign the item to the bin with the maximum score. }\\n\\n{My new algorithm assigns scores to the bins based on the ratio between the remaining capacity and the item size, prioritizing bins with lower indices, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * (1 / np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the sum of the bin's rest capacity and the item size squared, using the inverse of the bin number squared as the weight.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.square(np.arange(1, len(bins)+1))\\n scores = bins + np.square(item) * weights\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the square root of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) + np.arange(len(bins))\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n for i, capacity in enumerate(bins):\\n if capacity == item:\\n scores[i] = -1\\n elif capacity > item:\\n scores[i] = item - capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the scoring methods used in the existing algorithms, the new algorithm will calculate the scores for each bin based on the ratio between the item size and the remaining capacity, taking into account a weighted average using the reciprocal of the bin number and the square of the item size, as well as considering the number of items already assigned to each bin and aiming for an even distribution across all bins, ultimately minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.reciprocal(np.arange(1, len(bins)+1))\\n item_size_sq = np.square(item)\\n remaining_capacity = bins - item\\n \\n scores = (item_size_sq / remaining_capacity) * weights\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the bin number divided by the remaining capacity of the bin, aiming to assign items to bins with more remaining capacity first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.arange(1, len(bins) + 1))).astype(int)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its rest capacity and/or the ratio of item size to capacity, and then assign the item to the bin with the maximum score.}\\n\\n{New algorithm:}\\n\\n{1. Calculate the score for each bin based on the logarithm of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the product of its rest capacity and the logarithm of the item size, using a weighted average.\\n2. Sort the bins in descending order of their scores.\\n3. Assign the item to the first bin in the sorted list that has a rest capacity smaller than the maximum capacity and update its rest capacity accordingly.\\n4. Repeat steps 2 and 3 until all items have been assigned to bins.\\n5. Calculate the number of used bins as the total number of bins minus the number of bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)).mean()\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the remaining capacity to the item's value, with higher weights assigned to bins with lower indices, and assigns the item to the bin with the maximum score, minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacity_ratio = bins / item\\n indices = np.arange(num_bins)\\n weights = 1 / (indices + 1) # Higher weights assigned to bins with lower indices\\n\\n scores = capacity_ratio * weights\\n scores[bins == np.max(bins)] = 0 # Exclude bins with maximum capacity from being used\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the ratio of the item size to the remaining capacity, taking into account the inverse of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the score for each bin based on the sum of the bin's rest capacity and the item size cubed, using the inverse of the square root of the bin number as the weight.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.sqrt(np.arange(1, len(bins)+1))\\n rest_capacity = bins - item\\n scores = rest_capacity + item**3 * weights\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins, but additionally considers the number of items already assigned to each bin to adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = bin_capacity - item - np.sum(bins[:i])\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on the product of the item size, the inverse of the bin capacity, and a logarithmic function of the bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) \\n max_capacity = np.amax(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = item * (1 / bins[i]) * np.log(i+1)\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe common backbone idea in the provided algorithms is to calculate scores for each bin based on some ratio or difference involving the remaining capacity and the item size, and then assign the item to the bin with the maximum score. }\\n\\n{My new algorithm assigns scores to the bins based on the ratio between the remaining capacity and the item size, prioritizing bins with lower indices, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * (1 / np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the sum of the bin's rest capacity and the item size squared, using the inverse of the bin number squared as the weight.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.square(np.arange(1, len(bins)+1))\\n scores = bins + np.square(item) * weights\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using the remaining capacity and considering penalties for bins at maximum capacity, the new algorithm calculates the scores as the ratio between the item size and the remaining capacity, giving higher weights to bins with lower indices and aiming for an even distribution of items across bins to minimize their usage.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining_cap = bins - item\\n max_cap = np.max(bins)\\n penalty = (remaining_cap == max_cap).astype(np.float32)\\n idx = np.arange(len(bins))\\n weights = (1 - penalty) / (1 + idx)\\n scores = item / remaining_cap * weights\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n for i, capacity in enumerate(bins):\\n if capacity == item:\\n scores[i] = -1\\n elif capacity > item:\\n scores[i] = item - capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the scoring methods used in the existing algorithms, the new algorithm will calculate the scores for each bin based on the ratio between the item size and the remaining capacity, taking into account a weighted average using the reciprocal of the bin number and the square of the item size, as well as considering the number of items already assigned to each bin and aiming for an even distribution across all bins, ultimately minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.reciprocal(np.arange(1, len(bins)+1))\\n item_size_sq = np.square(item)\\n remaining_capacity = bins - item\\n \\n scores = (item_size_sq / remaining_capacity) * weights\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the bin number divided by the remaining capacity of the bin, aiming to assign items to bins with more remaining capacity first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.arange(1, len(bins) + 1))).astype(int)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its rest capacity and/or the ratio of item size to capacity, and then assign the item to the bin with the maximum score.}\\n\\n{New algorithm:}\\n\\n{1. Calculate the score for each bin based on the logarithm of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the product of its rest capacity and the logarithm of the item size, using a weighted average.\\n2. Sort the bins in descending order of their scores.\\n3. Assign the item to the first bin in the sorted list that has a rest capacity smaller than the maximum capacity and update its rest capacity accordingly.\\n4. Repeat steps 2 and 3 until all items have been assigned to bins.\\n5. Calculate the number of used bins as the total number of bins minus the number of bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)).mean()\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the remaining capacity to the item's value, with higher weights assigned to bins with lower indices, and assigns the item to the bin with the maximum score, minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacity_ratio = bins / item\\n indices = np.arange(num_bins)\\n weights = 1 / (indices + 1) # Higher weights assigned to bins with lower indices\\n\\n scores = capacity_ratio * weights\\n scores[bins == np.max(bins)] = 0 # Exclude bins with maximum capacity from being used\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the ratio of the item size to the remaining capacity, taking into account the inverse of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the score for each bin based on the sum of the bin's rest capacity and the item size cubed, using the inverse of the square root of the bin number as the weight.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.sqrt(np.arange(1, len(bins)+1))\\n rest_capacity = bins - item\\n scores = rest_capacity + item**3 * weights\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins, but additionally considers the number of items already assigned to each bin to adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = bin_capacity - item - np.sum(bins[:i])\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, taking into account the number of items already assigned to each bin, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n num_bins = len(bins)\\n used_bins = np.zeros(num_bins, dtype=bool)\\n \\n for i in range(num_bins):\\n if bins[i] == max_capacity:\\n continue\\n \\n remaining_capacity = max_capacity - bins[i]\\n num_items = np.sum(used_bins)\\n \\n score = (remaining_capacity/item) + num_items\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on the product of the item size, the inverse of the bin capacity, and a logarithmic function of the bin number, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) \\n max_capacity = np.amax(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = item * (1 / bins[i]) * np.log(i+1)\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on the ratio of the item size to the remaining capacity, weighted by a polynomial function of the bin number, aiming to balance the distribution of items across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = float(\\\"-inf\\\")\\n else:\\n scores[i] = (float(item) / remaining_capacity[i]) * (i+1)**2\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using the remaining capacity and considering penalties for bins at maximum capacity, the new algorithm calculates the scores as the ratio between the item size and the remaining capacity, giving higher weights to bins with lower indices and aiming for an even distribution of items across bins to minimize their usage.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining_cap = bins - item\\n max_cap = np.max(bins)\\n penalty = (remaining_cap == max_cap).astype(np.float32)\\n idx = np.arange(len(bins))\\n weights = (1 - penalty) / (1 + idx)\\n scores = item / remaining_cap * weights\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n for i, capacity in enumerate(bins):\\n if capacity == item:\\n scores[i] = -1\\n elif capacity > item:\\n scores[i] = item - capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the difference between the bin capacity and the item size, aiming to prioritize bins with higher remaining capacity and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n ratio = item / remaining_capacities\\n weights = bins - item\\n \\n scores = ratio * weights\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the scoring methods used in the existing algorithms, the new algorithm will calculate the scores for each bin based on the ratio between the item size and the remaining capacity, taking into account a weighted average using the reciprocal of the bin number and the square of the item size, as well as considering the number of items already assigned to each bin and aiming for an even distribution across all bins, ultimately minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.reciprocal(np.arange(1, len(bins)+1))\\n item_size_sq = np.square(item)\\n remaining_capacity = bins - item\\n \\n scores = (item_size_sq / remaining_capacity) * weights\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the bin number divided by the remaining capacity of the bin, aiming to assign items to bins with more remaining capacity first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.arange(1, len(bins) + 1))).astype(int)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its rest capacity and/or the ratio of item size to capacity, and then assign the item to the bin with the maximum score.}\\n\\n{New algorithm:}\\n\\n{1. Calculate the score for each bin based on the logarithm of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the product of its rest capacity and the logarithm of the item size, using a weighted average.\\n2. Sort the bins in descending order of their scores.\\n3. Assign the item to the first bin in the sorted list that has a rest capacity smaller than the maximum capacity and update its rest capacity accordingly.\\n4. Repeat steps 2 and 3 until all items have been assigned to bins.\\n5. Calculate the number of used bins as the total number of bins minus the number of bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)).mean()\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the remaining capacity to the item's value, with higher weights assigned to bins with lower indices, and assigns the item to the bin with the maximum score, minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacity_ratio = bins / item\\n indices = np.arange(num_bins)\\n weights = 1 / (indices + 1) # Higher weights assigned to bins with lower indices\\n\\n scores = capacity_ratio * weights\\n scores[bins == np.max(bins)] = 0 # Exclude bins with maximum capacity from being used\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the ratio of the item size to the remaining capacity, taking into account the inverse of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the score for each bin based on the sum of the bin's rest capacity and the item size cubed, using the inverse of the square root of the bin number as the weight.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.sqrt(np.arange(1, len(bins)+1))\\n rest_capacity = bins - item\\n scores = rest_capacity + item**3 * weights\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins, but additionally considers the number of items already assigned to each bin to adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = bin_capacity - item - np.sum(bins[:i])\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, taking into account the number of items already assigned to each bin, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n num_bins = len(bins)\\n used_bins = np.zeros(num_bins, dtype=bool)\\n \\n for i in range(num_bins):\\n if bins[i] == max_capacity:\\n continue\\n \\n remaining_capacity = max_capacity - bins[i]\\n num_items = np.sum(used_bins)\\n \\n score = (remaining_capacity/item) + num_items\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the existing algorithm by penalizing bins at maximum capacity with a higher penalty, and then calculates the scores as the ratio between the item size and the remaining capacity multiplied by the modified penalty and weights, aiming to reduce the usage of bins and evenly distribute items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n modified_penalty = np.where(bins == max_capacity, 2, 1)\\n remaining_capacity = bins - item\\n scores = (item / remaining_capacity) * modified_penalty\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using the remaining capacity and considering penalties for bins at maximum capacity, the new algorithm calculates the scores as the ratio between the item size and the remaining capacity, giving higher weights to bins with lower indices and aiming for an even distribution of items across bins to minimize their usage.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining_cap = bins - item\\n max_cap = np.max(bins)\\n penalty = (remaining_cap == max_cap).astype(np.float32)\\n idx = np.arange(len(bins))\\n weights = (1 - penalty) / (1 + idx)\\n scores = item / remaining_cap * weights\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio between item size and remaining capacity, penalties for bins at maximum capacity, and a weighted average considering the reciprocal of the bin number and the square of the item size, aiming for an even distribution of items and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(remaining_capacity)\\n \\n # Calculate ratio between item size and remaining capacity\\n ratio = item / remaining_capacity\\n \\n # Calculate penalties for bins at maximum capacity\\n penalties = np.where(remaining_capacity == max_capacity, -np.inf, 0)\\n \\n # Calculate weighted average\\n bin_number_weights = 1 / np.arange(1, len(bins)+1)\\n item_size_weights = item**2\\n \\n weighted_average = (bin_number_weights + item_size_weights) / 2\\n \\n # Calculate scores for bins\\n scores = ratio + penalties + weighted_average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n for i, capacity in enumerate(bins):\\n if capacity == item:\\n scores[i] = -1\\n elif capacity > item:\\n scores[i] = item - capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the difference between the bin capacity and the item size, aiming to prioritize bins with higher remaining capacity and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n ratio = item / remaining_capacities\\n weights = bins - item\\n \\n scores = ratio * weights\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n capacity_ratio = item / bins\\n scores = capacity_ratio - np.arange(num_bins) * 0.1\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the bin number squared plus the item size divided by the square root of the bin number, aiming to prioritize bins with higher remaining capacity and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.arange(1, len(bins)+1)**2) + (item / np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the bin number divided by the remaining capacity of the bin, aiming to assign items to bins with more remaining capacity first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.arange(1, len(bins) + 1))).astype(int)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its rest capacity and/or the ratio of item size to capacity, and then assign the item to the bin with the maximum score.}\\n\\n{New algorithm:}\\n\\n{1. Calculate the score for each bin based on the logarithm of the rest capacity and the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the product of its rest capacity and the logarithm of the item size, using a weighted average.\\n2. Sort the bins in descending order of their scores.\\n3. Assign the item to the first bin in the sorted list that has a rest capacity smaller than the maximum capacity and update its rest capacity accordingly.\\n4. Repeat steps 2 and 3 until all items have been assigned to bins.\\n5. Calculate the number of used bins as the total number of bins minus the number of bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)).mean()\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the bin number plus the square root of the item size, aiming to prioritize bins with higher remaining capacity and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.arange(1, len(bins)+1)) + np.sqrt(item))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the ratio of the item size to the remaining capacity, taking into account the inverse of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using the remaining capacity and considering penalties for bins at maximum capacity, the new algorithm calculates the scores as the ratio between the item size and the remaining capacity, giving higher weights to bins with lower indices and aiming for an even distribution of items across bins to minimize their usage.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining_cap = bins - item\\n max_cap = np.max(bins)\\n penalty = (remaining_cap == max_cap).astype(np.float32)\\n idx = np.arange(len(bins))\\n weights = (1 - penalty) / (1 + idx)\\n scores = item / remaining_cap * weights\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with lower indices, aiming to prioritize bins with higher indices and reduce the usage of low-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = bins.shape[0]\\n scores = np.zeros(n)\\n max_capacity = np.max(bins)\\n \\n for i in range(n):\\n capacity_ratio = item / (bins[i] - item) if bins[i] != max_capacity else 0\\n index_penalty = 1 / (i + 1)\\n scores[i] = capacity_ratio + index_penalty\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio between item size and remaining capacity, penalties for bins at maximum capacity, and a weighted average considering the reciprocal of the bin number and the square of the item size, aiming for an even distribution of items and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(remaining_capacity)\\n \\n # Calculate ratio between item size and remaining capacity\\n ratio = item / remaining_capacity\\n \\n # Calculate penalties for bins at maximum capacity\\n penalties = np.where(remaining_capacity == max_capacity, -np.inf, 0)\\n \\n # Calculate weighted average\\n bin_number_weights = 1 / np.arange(1, len(bins)+1)\\n item_size_weights = item**2\\n \\n weighted_average = (bin_number_weights + item_size_weights) / 2\\n \\n # Calculate scores for bins\\n scores = ratio + penalties + weighted_average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's normalized load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment, with the added modification of penalizing bins that are at maximum capacity by setting their scores to -np.inf.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratios = (bins - item) / bins\\n load_ratios[load_ratios == 1] = -np.inf\\n scores = (bins - item) / (bins * load_ratios)\\n scores[scores == -np.inf] = np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n for i, capacity in enumerate(bins):\\n if capacity == item:\\n scores[i] = -1\\n elif capacity > item:\\n scores[i] = item - capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the difference between the bin capacity and the item size, aiming to prioritize bins with higher remaining capacity and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n ratio = item / remaining_capacities\\n weights = bins - item\\n \\n scores = ratio * weights\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n capacity_ratio = item / bins\\n scores = capacity_ratio - np.arange(num_bins) * 0.1\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the bin number squared plus the item size divided by the square root of the bin number, aiming to prioritize bins with higher remaining capacity and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.arange(1, len(bins)+1)**2) + (item / np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the bin number divided by the remaining capacity of the bin, aiming to assign items to bins with more remaining capacity first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.arange(1, len(bins) + 1))).astype(int)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New algorithm:}\\n\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the square root of the bin number, using a weighted average.}\\n\\n{2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n sqrt_bin_number = np.sqrt(np.arange(1, non_zero_bin_count + 1))\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, sqrt_bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate the score for each bin based on a combination of the item's size and the bin's capacity or load ratio.}\\n\\n{New algorithm: The score function calculates the scores for each bin by taking the difference between the item size and the bin capacity and dividing it by the product of the bin capacity and the bin load ratio, aiming to balance the distribution of items and minimize the usage of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (bins * (1 - item/bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Assign scores to bins based on the ratio of item size to remaining capacity, taking into account factors such as bin number, bin capacity, and number of items in the bin.}\\n\\nNew algorithm description: {The new algorithm assigns scores to bins based on a weighted combination of the item size and the square of the bin number, aiming to prioritize larger items and evenly distribute them across bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Bin numbers\\n capacities = bins - item # Remaining capacities after assigning the item\\n\\n # Calculate scores as a weighted combination of item size and square of bin number\\n scores = item / capacities + bin_nums**2\\n\\n # Filter out bins with maximum capacity\\n scores[capacities == max(capacities)] = 0\\n\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:}\\n{1. Calculate the score for each bin based on the inverse of the rest capacity and the bin number divided by the item, using a weighted average.}\\n\\n{\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n max_capacity = np.max(bins)\\n \\n mask = bins != max_capacity\\n non_zero_bin_count = np.count_nonzero(mask)\\n \\n if non_zero_bin_count == 0:\\n scores[0] = -np.inf # No feasible bins, assign score as negative infinity\\n return scores\\n \\n inv_rest_capacity = 1 / (bins[mask] - item)\\n bin_number = np.arange(1, non_zero_bin_count + 1) / item\\n \\n scores[mask] = np.average(np.column_stack((inv_rest_capacity, bin_number)), axis=1)\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with higher indices, aiming to prioritize bins with lower indices and reduce the usage of high-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n ratios = item / remaining_capacities\\n penalties = indices[::-1]\\n \\n scores = ratios - penalties\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the remaining capacity divided by the item size and the bin's current load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n load_ratios = 1 - item / bins\\n scores = capacities / load_ratios\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using the remaining capacity and considering penalties for bins at maximum capacity, the new algorithm calculates the scores as the ratio between the item size and the remaining capacity, giving higher weights to bins with lower indices and aiming for an even distribution of items across bins to minimize their usage.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining_cap = bins - item\\n max_cap = np.max(bins)\\n penalty = (remaining_cap == max_cap).astype(np.float32)\\n idx = np.arange(len(bins))\\n weights = (1 - penalty) / (1 + idx)\\n scores = item / remaining_cap * weights\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the difference between the item and the rest capacity, using a weighted average with the reciprocal of the bin number, while penalizing bins at maximum capacity and prioritizing bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n scores = (item - bins) * weights\\n scores[bins == np.max(bins)] = -np.inf\\n scores[bins == np.max(bins) - item] -= np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the score for each bin based on the item divided by the rest capacity, using a weighted average with the bin number.\\n2. If the rest capacity of a bin equals the maximum capacity, assign a score of negative infinity to that bin.\\n3. Assign the item to the bin with the maximum score in each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n scores[bins == max_capacity] = float('-inf')\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item)\\n \\n scores *= np.arange(1, bins.size+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the ratio between the item size and the remaining capacity, with an additional penalty for bins with lower indices, aiming to prioritize bins with higher indices and reduce the usage of low-index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = bins.shape[0]\\n scores = np.zeros(n)\\n max_capacity = np.max(bins)\\n \\n for i in range(n):\\n capacity_ratio = item / (bins[i] - item) if bins[i] != max_capacity else 0\\n index_penalty = 1 / (i + 1)\\n scores[i] = capacity_ratio + index_penalty\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item's value to the square of the remaining capacity of the bin, using a weighted average determined by the reciprocal of the bin number, and then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = item / (remaining_capacity ** 2) * weights\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the ratio between item size and remaining capacity, penalties for bins at maximum capacity, and a weighted average considering the reciprocal of the bin number and the square of the item size, aiming for an even distribution of items and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(remaining_capacity)\\n \\n # Calculate ratio between item size and remaining capacity\\n ratio = item / remaining_capacity\\n \\n # Calculate penalties for bins at maximum capacity\\n penalties = np.where(remaining_capacity == max_capacity, -np.inf, 0)\\n \\n # Calculate weighted average\\n bin_number_weights = 1 / np.arange(1, len(bins)+1)\\n item_size_weights = item**2\\n \\n weighted_average = (bin_number_weights + item_size_weights) / 2\\n \\n # Calculate scores for bins\\n scores = ratio + penalties + weighted_average\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins by multiplying the item size with the inverse of the rest capacity, taking into account the difference between the item size and the rest capacity, and prioritizing bins with lower indices, and returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n \\n # Calculate the inverse of rest capacities\\n inv_caps = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = item * inv_caps * (item - bins) * np.arange(N, 0, -1)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity divided by the item size and the bin's normalized load ratio, prioritizing bins with lower load ratios and higher indices, and returning the scores for assignment, with the added modification of penalizing bins that are at maximum capacity by setting their scores to -np.inf.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n load_ratios = (bins - item) / bins\\n load_ratios[load_ratios == 1] = -np.inf\\n scores = (bins - item) / (bins * load_ratios)\\n scores[scores == -np.inf] = np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the item's value and the inverse of the bin number, aiming to distribute items evenly across all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the ratio between the item size and the remaining capacity of each bin, weighted by factors such as the difference between the bin capacity and item size or the bin load ratio.}\\n\\n{New algorithm: The score function assigns scores to each bin by considering the maximum factor between the ratio of the item size to the remaining capacity and the ratio of the bin load to the bin capacity, aiming to balance the distribution of items while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = np.maximum(item / bins, bins / np.max(bins))\\n scores = np.where(bins == np.max(bins), 0, ratios)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the inverse of the bin number and a decreasing term, aiming to distribute items evenly across all bins while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = len(bins)\\n bin_range = np.arange(1, bin_num + 1)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n weights = 1 / (bin_range**2)\\n decreasing_terms = np.exp(-bin_range)\\n scores = ratios * weights * decreasing_terms\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate scores for each bin\\n for i, capacity in enumerate(bins):\\n if capacity == item:\\n scores[i] = -1\\n elif capacity > item:\\n scores[i] = item - capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of the item size to the remaining capacity, weighted by the difference between the bin capacity and the item size, aiming to prioritize bins with higher remaining capacity and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n ratio = item / remaining_capacities\\n weights = bins - item\\n \\n scores = ratio * weights\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins * (1 - item/bins) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: The score function will assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and the ratio of remaining capacity to item size, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n distances = np.abs(bins - item)\\n scores = (bins * ratios) / distances\\n \\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on a combination of the ratio between the item size and bin capacity, the proximity to the maximum capacity, and a penalty for bins that have already been used, returning the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / bins\\n proximity = (bins.max() - bins) / bins.max()\\n penalty = np.where(bins == bins.max(), np.inf, 0)\\n scores = ratio + proximity - penalty\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a variation of the original algorithm that takes into account the ratio between the item size and the rest capacity of each bin when calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity >= item:\\n scores[i] = item / bin_capacity\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the ratio of remaining capacity to item size, prioritizing bins with lower remaining capacity and higher index, and penalizing bins at maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n # Assign scores based on the ratio of remaining capacity to item size\\n scores = remaining_capacity / item\\n \\n # Prioritize bins with lower remaining capacity and higher index\\n scores += np.arange(len(bins), 0, -1)\\n \\n # Penalize bins at maximum capacity\\n scores[max_capacity == bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the remaining capacity, the number of items already assigned, and a penalty for bins at maximum capacity, then returns the scores for each bin in a numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == np.max(bins)) * np.Inf\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin by taking the product of the rest capacity and the inverse of the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(bins, np.reciprocal(np.arange(1, len(bins)+1, dtype=float)))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n\\n # Calculate the score for each bin\\n for i in range(len(bins)):\\n if bins[i] != item:\\n scores[i] = 1 / (bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n for i, capacity in enumerate(bins):\\n # If bin is unused, skip it\\n if capacity == item:\\n scores[i] = -1\\n continue\\n # Assign score based on remaining capacity\\n scores[i] = 1 / (capacity - item + 1)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on the ratio of remaining capacity to item size, penalizing bins at maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Create an array of zeros with the same shape as 'bins'\\n max_capacity = np.max(bins) # Find the maximum capacity among the bins\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1 # Penalize bins at maximum capacity\\n else:\\n scores[i] = bins[i] / item # Calculate the score based on the ratio of remaining capacity to item size\\n \\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function calculates the scores for each bin based on the ratio of its remaining capacity to the number of items already assigned to it, penalizing bins with maximum capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.arange(1, len(bins) + 1)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the scores for each bin based on the ratio of remaining capacity to item size and the number of items already assigned, prioritizing bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item # calculate remaining capacity of each bin\\n num_items_assigned = np.arange(1, len(bins)+1) # calculate number of items already assigned to each bin\\n scores = remaining_capacity / item * (1 / num_items_assigned) # calculate scores based on given formula\\n scores[bins == np.max(bins)] = -np.inf # set maximum capacity bins to -infinity score\\n return scores\",\n \"objective\": 0.06439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will assign scores to each bin based on a combination of the bin's remaining capacity, ratio of remaining capacity to item size, proximity to item size, number of items already assigned, and penalize bins with maximum capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n proximity = np.abs(item - remaining_capacity)\\n num_assigned = np.arange(1, len(bins)+1)\\n penalize = (bins == np.max(bins)).astype(int)\\n \\n scores = remaining_capacity + ratio + proximity + num_assigned - penalize\\n return scores\",\n \"objective\": 0.09629,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will sort the bins in ascending order and assign the item to the bin with the lowest capacity until a bin with maximum capacity is reached, then it will stop assigning and return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n used_bins = 0\\n scores = np.zeros_like(bins)\\n\\n for i in range(len(sorted_bins)):\\n if sorted_bins[i] == bins.max():\\n break\\n if sorted_bins[i] >= item:\\n scores[i] = sorted_bins[i] - item\\n used_bins += 1\\n\\n return scores\",\n \"objective\": 0.0984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the square root of the item size to the remaining capacity, multiplied by the inverse of the bin index plus one, and return the scores for assignment. The main steps are to calculate the remaining capacity of each bin, compute the ratio of the square root of the item size to the remaining capacity, multiply it by the inverse of the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item # calculate remaining capacity of each bin\\n sqrt_ratio = np.sqrt(item) / remaining_capacity # ratio of square root of item size to remaining capacity\\n inverse_bin_index = 1 / (np.arange(len(bins)) + 1) # inverse of bin index plus one\\n scores = sqrt_ratio * inverse_bin_index # compute scores for each bin\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the bin index plus one, divided by the remaining capacity raised to the power of two, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (np.arange(len(bins)) + 1)) /\\n (bins - item + 1) ** 2).astype(np.float64)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main algorithm parameter is the item size, bins capacity, and the scoring function which assigns scores to each bin based on the exponential of the sum of the item size and remaining capacity divided by the bin index plus one. \\nFor the new algorithm, we will modify the scoring function to assign scores based only on the remaining capacity of the bins, without considering the item size, using an inverse exponential function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/(item+1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse ratio of the bin index plus one to the remaining capacity raised to the power of three, ensuring a modified scoring system that prioritizes filling smaller capacity bins first, while still considering the uniqueness and distinctness of the scoring system in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n \\n # Calculate scores based on the inverse ratio of bin index\\n scores = 1.0 / (np.arange(len(bins)) + 1)\\n \\n # Raise the remaining capacity of each bin to the power of three\\n scores *= np.power(bins, 3)\\n \\n # Disable bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0.0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the sum of the remaining capacity and bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the inverse of the ratio of the item size to the remaining capacity, the square of the bin number, and the ratio of the remaining capacity to the item size, ensuring a different scoring system than the existing algorithm while aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.square(np.arange(1, bins.size + 1))) * ((bins - item) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the bin index plus one, without excluding any bins based on maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the square root of the item size to the remaining capacity, multiplied by the inverse of the bin index plus one, and return the scores for assignment. The main steps are to calculate the remaining capacity of each bin, compute the ratio of the square root of the item size to the remaining capacity, multiply it by the inverse of the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item # calculate remaining capacity of each bin\\n sqrt_ratio = np.sqrt(item) / remaining_capacity # ratio of square root of item size to remaining capacity\\n inverse_bin_index = 1 / (np.arange(len(bins)) + 1) # inverse of bin index plus one\\n scores = sqrt_ratio * inverse_bin_index # compute scores for each bin\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the bin index plus one, divided by the remaining capacity raised to the power of two, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (np.arange(len(bins)) + 1)) /\\n (bins - item + 1) ** 2).astype(np.float64)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores the bins based on the inverse exponential of the remaining capacity only, without considering the item size, using the formula scores = np.exp(-bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins)\\n\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse ratio of the bin index plus one to the remaining capacity raised to the power of three, ensuring a modified scoring system that prioritizes filling smaller capacity bins first, while still considering the uniqueness and distinctness of the scoring system in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n \\n # Calculate scores based on the inverse ratio of bin index\\n scores = 1.0 / (np.arange(len(bins)) + 1)\\n \\n # Raise the remaining capacity of each bin to the power of three\\n scores *= np.power(bins, 3)\\n \\n # Disable bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0.0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the sum of the remaining capacity and bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the inverse of the ratio of the item size to the remaining capacity, the square of the bin number, and the ratio of the remaining capacity to the item size, ensuring a different scoring system than the existing algorithm while aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.square(np.arange(1, bins.size + 1))) * ((bins - item) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the bin index plus one, without excluding any bins based on maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum of squared divided by remaining capacity minus index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.square(bins) / (bins - item)) - (np.arange(len(bins)) * item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the square root of the remaining capacity to twice the bin index plus one, ensuring a unique scoring system that prioritizes filling larger capacity bins first while considering the distinctness of the scoring system in the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (2*np.arange(1,len(bins)+1) + 1)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse ratio of the bin index plus one to the remaining capacity raised to the power of three, ensuring a modified scoring system that prioritizes filling smaller capacity bins first, while still considering the uniqueness and distinctness of the scoring system in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n \\n # Calculate scores based on the inverse ratio of bin index\\n scores = 1.0 / (np.arange(len(bins)) + 1)\\n \\n # Raise the remaining capacity of each bin to the power of three\\n scores *= np.power(bins, 3)\\n \\n # Disable bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0.0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (1 / bins)).astype(int)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the inverse of the ratio of the item size to the remaining capacity, the square of the bin number, and the ratio of the remaining capacity to the item size, ensuring a different scoring system than the existing algorithm while aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.square(np.arange(1, bins.size + 1))) * ((bins - item) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum of squared divided by remaining capacity minus index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.square(bins) / (bins - item)) - (np.arange(len(bins)) * item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the square root of the remaining capacity to twice the bin index plus one, ensuring a unique scoring system that prioritizes filling larger capacity bins first while considering the distinctness of the scoring system in the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (2*np.arange(1,len(bins)+1) + 1)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse ratio of the bin index plus one to the remaining capacity raised to the power of three, ensuring a modified scoring system that prioritizes filling smaller capacity bins first, while still considering the uniqueness and distinctness of the scoring system in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n \\n # Calculate scores based on the inverse ratio of bin index\\n scores = 1.0 / (np.arange(len(bins)) + 1)\\n \\n # Raise the remaining capacity of each bin to the power of three\\n scores *= np.power(bins, 3)\\n \\n # Disable bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0.0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the item size and the inverse of the remaining capacity, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (1 / bins)).astype(int)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum of squared divided by remaining capacity minus index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.square(bins) / (bins - item)) - (np.arange(len(bins)) * item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the sum of the item size and bin capacity to the cube root of the bin index, excluding bins with rest capacity equal to the maximum capacity, and return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / np.cbrt(range(1, len(bins)+1))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the remaining capacity to the cube root of the bin index plus one, excluding bins with rest capacity equal to the maximum capacity, and return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.power(np.arange(1, len(bins)+1), 1/3))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum of squared divided by remaining capacity minus index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.square(bins) / (bins - item)) - (np.arange(len(bins)) * item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n used_bins = np.where(bins != max_capacity)[0]\\n scores[used_bins] = ((max_capacity - bins[used_bins]) / max_capacity) * item\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the sum of the item size and bin capacity to the cube root of the bin index, excluding bins with rest capacity equal to the maximum capacity, and return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / np.cbrt(range(1, len(bins)+1))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum of squared divided by remaining capacity minus index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.square(bins) / (bins - item)) - (np.arange(len(bins)) * item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the inverse of the remaining capacity, the logarithm (base 2) of the item size, and the bin number, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log2(item) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n used_bins = np.where(bins != max_capacity)[0]\\n scores[used_bins] = ((max_capacity - bins[used_bins]) / max_capacity) * item\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1 # Ignore bins with exact capacity\\n scores = (capacities - item) / (capacities // item) # Calculate scores\\n scores = np.where(capacities == 0, 0, scores) # Assign 0 score to bins with no capacity\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum of squared divided by remaining capacity minus index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.square(bins) / (bins - item)) - (np.arange(len(bins)) * item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the inverse of the remaining capacity, the logarithm (base 2) of the item size, and the bin number, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log2(item) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for bins based on the remaining capacity of the bin and the item's size.}\\n\\n{New algorithm description: Assign scores to bins based on the logarithm (base 2) of the item size divided by the square root of the remaining capacity, multiplied by the bin number, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log2(item / np.sqrt(bins))*np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n used_bins = np.where(bins != max_capacity)[0]\\n scores[used_bins] = ((max_capacity - bins[used_bins]) / max_capacity) * item\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the inverse of the remaining capacity, the logarithm (base 2) of the item size, and the bin number, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log2(item) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for bins based on the remaining capacity of the bin and the item's size.}\\n\\n{New algorithm description: Assign scores to bins based on the logarithm (base 2) of the item size divided by the square root of the remaining capacity, multiplied by the bin number, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log2(item / np.sqrt(bins))*np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the sum of the item divided by the remaining capacity of the bin, multiplied by the bin index plus the square of the item's square root.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.arange(len(bins)) + 1) + item**0.5 ** 2\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the difference between the cube root of the item size divided by the square root of the remaining capacity, subtracted by the product of the bin number and the logarithm (base 10) of the remaining capacity. Main steps: Calculate the remaining capacity of each bin, compute the cube root of the item size divided by the square root of the remaining capacity, multiply the bin number by the logarithm (base 10) of the remaining capacity, and subtract the two values to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cube_root = np.cbrt(item) / np.sqrt(remaining_capacity)\\n log_value = np.log10(remaining_capacity)\\n bin_number = np.arange(len(bins))\\n scores = cube_root - (bin_number * log_value)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the ratio between the item and the remaining capacity of the bin, and then assigns the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the inverse of the remaining capacity, the logarithm (base 2) of the item size, and the bin number, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log2(item) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: The score function will assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and the ratio of remaining capacity to item size, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n distances = np.abs(bins - item)\\n scores = (bins * ratios) / distances\\n \\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the ratio of remaining capacity to the square of the item size, penalizing bins at maximum capacity and prioritizing bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)**2) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the sum of the rest capacity and the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n index = np.arange(len(bins))\\n scores = 1 / (rest_capacity + index)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the ratio of remaining capacity to item size, prioritizing bins with lower remaining capacity and higher index, and penalizing bins at maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n # Assign scores based on the ratio of remaining capacity to item size\\n scores = remaining_capacity / item\\n \\n # Prioritize bins with lower remaining capacity and higher index\\n scores += np.arange(len(bins), 0, -1)\\n \\n # Penalize bins at maximum capacity\\n scores[max_capacity == bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the remaining capacity, the number of items already assigned, and a penalty for bins at maximum capacity, then returns the scores for each bin in a numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == np.max(bins)) * np.Inf\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on certain criteria and choose the bin with the highest score for item assignment.}\\n\\n{New algorithm: Calculate the score for each bin by considering the remaining capacity of the bin divided by the product of the bin index and the item size, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(len(bins)) + 1) / item\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin by taking the product of the rest capacity and the inverse of the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(bins, np.reciprocal(np.arange(1, len(bins)+1, dtype=float)))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by considering the logarithm of the remaining capacity divided by the sum of the bin index and item size, penalizing bins at maximum capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (np.arange(len(bins)) + item))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.05031,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n\\n # Calculate the score for each bin\\n for i in range(len(bins)):\\n if bins[i] != item:\\n scores[i] = 1 / (bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins, set the score to -1 for bins with rest capacity equal to the maximum capacity, and for the remaining feasible bins, set the score to a value inversely proportional to the remaining capacity, and return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = -1\\n scores[bins != max_capacity] = 1 / remaining_capacity[bins != max_capacity]\\n \\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the sum of the rest capacity and the inverse of the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + 1) / (np.arange(bins.size) + 1)\\n scores[bins == item] = 0\\n return scores\",\n \"objective\": 0.05343,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on both the rest capacity and the inverse of the bin number, using a modified weighting factor, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins/item) + (1/(np.arange(1, len(bins)+1))) * 1000\\n scores[bins == item] = 0\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on the ratio of remaining capacity to item size, penalizing bins at maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Create an array of zeros with the same shape as 'bins'\\n max_capacity = np.max(bins) # Find the maximum capacity among the bins\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1 # Penalize bins at maximum capacity\\n else:\\n scores[i] = bins[i] / item # Calculate the score based on the ratio of remaining capacity to item size\\n \\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by considering the square root of the remaining capacity divided by the cube of the sum of the bin index and item size, penalizing bins at maximum capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n score = np.sqrt(rest_capacity) / (np.power(i + 1, 3) + np.power(item, 3))\\n scores[i] = score\\n\\n return scores\",\n \"objective\": 0.06097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function calculates the scores for each bin based on the ratio of its remaining capacity to the number of items already assigned to it, penalizing bins with maximum capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.arange(1, len(bins) + 1)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates the scores by dividing the cube of the item by the remaining capacity multiplied by bin size, then adding the index multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item ** 3) / (bins * (bins - item)) + np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the square root of the inverse of the remaining capacity, subtracting the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the square root of the inverse of the remaining capacity, subtract the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = item * np.sqrt(1 / remaining_capacity) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the sum of the item divided by the remaining capacity of the bin, multiplied by the bin index plus the square of the item's square root.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.arange(len(bins)) + 1) + item**0.5 ** 2\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the difference between the cube root of the item size divided by the square root of the remaining capacity, subtracted by the product of the bin number and the logarithm (base 10) of the remaining capacity. Main steps: Calculate the remaining capacity of each bin, compute the cube root of the item size divided by the square root of the remaining capacity, multiply the bin number by the logarithm (base 10) of the remaining capacity, and subtract the two values to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cube_root = np.cbrt(item) / np.sqrt(remaining_capacity)\\n log_value = np.log10(remaining_capacity)\\n bin_number = np.arange(len(bins))\\n scores = cube_root - (bin_number * log_value)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates the scores by dividing the cube of the item by the remaining capacity multiplied by bin size, then adding the index multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item ** 3) / (bins * (bins - item)) + np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the square root of the inverse of the remaining capacity, subtracting the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the square root of the inverse of the remaining capacity, subtract the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = item * np.sqrt(1 / remaining_capacity) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the sum of the item divided by the remaining capacity of the bin, multiplied by the bin index plus the square of the item's square root.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.arange(len(bins)) + 1) + item**0.5 ** 2\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the difference between the cube root of the item size divided by the square root of the remaining capacity, subtracted by the product of the bin number and the logarithm (base 10) of the remaining capacity. Main steps: Calculate the remaining capacity of each bin, compute the cube root of the item size divided by the square root of the remaining capacity, multiply the bin number by the logarithm (base 10) of the remaining capacity, and subtract the two values to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cube_root = np.cbrt(item) / np.sqrt(remaining_capacity)\\n log_value = np.log10(remaining_capacity)\\n bin_number = np.arange(len(bins))\\n scores = cube_root - (bin_number * log_value)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity, multiplied by the inverse of the bin index plus three, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (1 / (np.arange(len(bins)) + 1) + 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the cosine of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin number. Main steps: Calculate the remaining capacity of each bin, compute the cosine of the ratio between the item size and the remaining capacity, take the inverse, and multiply it by the square root of the bin number to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cosine_ratio = np.cos(item / remaining_capacity)\\n scores = 1 / cosine_ratio * np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates the scores by dividing the cube of the item by the remaining capacity multiplied by bin size, then adding the index multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item ** 3) / (bins * (bins - item)) + np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the square root of the inverse of the remaining capacity, subtracting the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the square root of the inverse of the remaining capacity, subtract the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = item * np.sqrt(1 / remaining_capacity) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the sum of the item divided by the remaining capacity of the bin, multiplied by the bin index plus the square of the item's square root.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.arange(len(bins)) + 1) + item**0.5 ** 2\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the sum of the cube root of the item size divided by the square of the remaining capacity, subtracted by the logarithm (base 2) of the bin number, ensuring a unique scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(item) / np.square(bins - item)) - np.log2(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the cosine of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin number. Main steps: Calculate the remaining capacity of each bin, compute the cosine of the ratio between the item size and the remaining capacity, take the inverse, and multiply it by the square root of the bin number to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cosine_ratio = np.cos(item / remaining_capacity)\\n scores = 1 / cosine_ratio * np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates the scores by dividing the cube of the item by the remaining capacity multiplied by bin size, then adding the index multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item ** 3) / (bins * (bins - item)) + np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the square root of the inverse of the remaining capacity, subtracting the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the square root of the inverse of the remaining capacity, subtract the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = item * np.sqrt(1 / remaining_capacity) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the sum of the item divided by the remaining capacity of the bin, multiplied by the bin index plus the square of the item's square root.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.arange(len(bins)) + 1) + item**0.5 ** 2\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the sum of the cube root of the item size divided by the square of the remaining capacity, subtracted by the logarithm (base 2) of the bin number, ensuring a unique scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(item) / np.square(bins - item)) - np.log2(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the inverse of the remaining capacity, multiplied by the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the sum of the item size and the inverse of the remaining capacity, multiply it by the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (item + 1 / remaining_capacity) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the cosine of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin number. Main steps: Calculate the remaining capacity of each bin, compute the cosine of the ratio between the item size and the remaining capacity, take the inverse, and multiply it by the square root of the bin number to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cosine_ratio = np.cos(item / remaining_capacity)\\n scores = 1 / cosine_ratio * np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the square of the cosine of the ratio between the item size and remaining capacity, multiplied by the logarithm of the bin number plus one. Main steps: Calculate the remaining capacity of each bin, compute the cosine ratio, take the inverse and square it, then multiply it by the logarithm of the bin number plus one to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cosine_ratio = np.cos(item / remaining_capacity)\\n inverse_square = np.power(1 / cosine_ratio, 2)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = inverse_square * np.log(bin_numbers)\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates the scores by dividing the cube of the item by the remaining capacity multiplied by bin size, then adding the index multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item ** 3) / (bins * (bins - item)) + np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the square root of the inverse of the remaining capacity, subtracting the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the square root of the inverse of the remaining capacity, subtract the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = item * np.sqrt(1 / remaining_capacity) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the sum of the item divided by the remaining capacity of the bin, multiplied by the bin index plus the square of the item's square root.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.arange(len(bins)) + 1) + item**0.5 ** 2\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the sum of the cube root of the item size divided by the square of the remaining capacity, subtracted by the logarithm (base 2) of the bin number, ensuring a unique scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(item) / np.square(bins - item)) - np.log2(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"scores = (1 / np.log(item / remaining_capacity)) * (np.cbrt(np.arange(len(bins)) + 1)) * (np.exp(item))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.array(bins)\\n scores = (1 / np.log(item / remaining_capacity)) * (np.cbrt(np.arange(len(bins)) + 1)) * (np.exp(item))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size, and extends the scoring by dividing the remaining capacity of each bin by the sum of the sizes of all remaining items, effectively favoring bins with a smaller remaining capacity and larger remaining items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape) # Initialize scores array\\n \\n # Calculate scores for each bin\\n scores[bins != item] = bins[bins != item] % item\\n scores[bins == item] = item\\n \\n # Extend scoring by dividing remaining capacity of each bin by sum of sizes of remaining items\\n remaining_items = np.sum(bins[bins > item]) - item\\n scores[bins != item] += bins[bins != item] / remaining_items\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the cosine of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin number. Main steps: Calculate the remaining capacity of each bin, compute the cosine of the ratio between the item size and the remaining capacity, take the inverse, and multiply it by the square root of the bin number to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cosine_ratio = np.cos(item / remaining_capacity)\\n scores = 1 / cosine_ratio * np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: \\n- item (the item that needs to be assigned to a bin)\\n- bins (the set of bins available for assigning the item)\\n\\nNew algorithm description: \\nThe new algorithm modifies the score function by assigning different scores based on the remaining capacity of each bin compared to the item, with the goal of minimizing the number of used bins.\\nThe main steps of the new algorithm are: \\n- Clone the bins set as capacities.\\n- Set the capacity of bins with exact capacity equal to item as -1 to ignore them.\\n- Calculate scores by subtracting the item from each capacity and dividing it by the integer division of capacity by item.\\n- Set scores of bins with no capacity to 0.\\n- Return the scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = (capacities - item) / (capacities // item)\\n scores[capacities == 0] = 0\\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the reciprocal of the square root of the remaining capacity multiplied by the cube of the bin index, aiming to optimize bin assignment with a distinct scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n used_bins = np.sum(bins < max_capacity)\\n reciprocal_sqrt_rest_capacity = 1 / np.sqrt(bins - item)\\n scores = reciprocal_sqrt_rest_capacity * (np.power(bins, 3))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the square of the cosine of the ratio between the item size and remaining capacity, multiplied by the logarithm of the bin number plus one. Main steps: Calculate the remaining capacity of each bin, compute the cosine ratio, take the inverse and square it, then multiply it by the logarithm of the bin number plus one to obtain the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n cosine_ratio = np.cos(item / remaining_capacity)\\n inverse_square = np.power(1 / cosine_ratio, 2)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = inverse_square * np.log(bin_numbers)\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates the scores by dividing the cube of the item by the remaining capacity multiplied by bin size, then adding the index multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item ** 3) / (bins * (bins - item)) + np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores by dividing the square of the item by remaining capacity minus bin size divided by item size, then subtracting index multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins - item) - np.arange(len(bins)) * item\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the remaining capacity, subtracting the square of the bin number, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the ratio of the item size to the remaining capacity, subtract the square of the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n \\n ratios = item / remaining_capacities\\n \\n bin_numbers = np.arange(len(bins)) + 1\\n bin_numbers_squared = bin_numbers**2\\n \\n scores = ratios - bin_numbers_squared\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the square root of the inverse of the remaining capacity, subtracting the bin index plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the square root of the inverse of the remaining capacity, subtract the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = item * np.sqrt(1 / remaining_capacity) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the exponential (base e) of the inverse of the ratio between the remaining capacity and the item size, divided by the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(1 / (bins - item) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the inverse of the ratio of the remaining capacity to the item size, subtracting the product of the bin number and the square root of the remaining capacity, ensuring a modified scoring system. Main steps: Compute the remaining capacity of each bin, calculate the inverse of the ratio of the remaining capacity to the item size, subtract the product of the bin number and the square root of the remaining capacity, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n scores = (1 / ratio) - (bin_number * np.sqrt(remaining_capacity))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the sum of the item divided by the remaining capacity of the bin, multiplied by the bin index plus the square of the item's square root.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.arange(len(bins)) + 1) + item**0.5 ** 2\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the remaining capacity, multiplied by the bin number, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the logarithm of the item size divided by the remaining capacity, multiply by the bin number, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins by calculating the logarithm of the ratio between the item and the remaining capacity of the bin, multiplied by the square root of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the ratio of the inverse of the remaining capacity squared divided by the bin index squared plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins**2 - item**2 + 1)) / (np.arange(len(bins))**2 + 1)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: The score function will assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and the ratio of remaining capacity to item size, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n distances = np.abs(bins - item)\\n scores = (bins * ratios) / distances\\n \\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm 6 (Reverse Ratio): The score function assigns scores to each bin based on the inverse of the ratio between the item size and the bin's remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the sum of the rest capacity and the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n index = np.arange(len(bins))\\n scores = 1 / (rest_capacity + index)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: item (size of the item to be assigned), bins (a list of bin capacities).\\nNew algorithm: The new algorithm assigns scores to bins based on the square root of the item size multiplied by the remaining capacity, the bin number squared, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithm.\\nMain steps: Compute the remaining capacity of each bin, calculate the square root of the item size multiplied by the remaining capacity, compute the square of the bin numbers, calculate the inverse of the remaining capacity, sum up the three calculated values, and return the scores for each bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n sqrt_item_capacity = np.sqrt(item * remaining_capacity)\\n bin_number_squared = np.power(np.arange(len(bins)), 2)\\n inverse_remaining_capacity = 1 / remaining_capacity\\n scores = sqrt_item_capacity + bin_number_squared + inverse_remaining_capacity\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size and the bin number, subtracting the sum of the remaining capacity and the square root of the item size, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.arange(1, len(bins)+1)) - (np.sqrt(item) + bins)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins - item) != np.max(bins)).astype(int)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on certain criteria and choose the bin with the highest score for item assignment.}\\n\\n{New algorithm: Calculate the score for each bin by considering the remaining capacity of the bin divided by the product of the bin index and the item size, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(len(bins)) + 1) / item\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"M\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[bins != np.max(bins)] = (np.max(bins) - bins[bins != np.max(bins)]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin by taking the product of the rest capacity and the inverse of the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(bins, np.reciprocal(np.arange(1, len(bins)+1, dtype=float)))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: Assign scores to bins based on the sum of the item size multiplied by the remaining capacity, the bin number squared, and the inverse of the remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of item sizes multiplied by remaining capacity\\n sum_sizes = bins * (item + bins)\\n \\n # Calculate the bin number squared\\n bin_numbers = np.arange(1, len(bins) + 1) ** 2\\n \\n # Calculate the inverse of remaining capacity\\n inv_capacities = 1 / bins\\n \\n # Calculate the scores for each bin\\n scores = sum_sizes + bin_numbers + inv_capacities\\n \\n return scores\",\n \"objective\": 0.04467,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by considering the sum of the bin index and item size divided by the remaining capacity of the bin, penalizing bins at maximum capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = (bins[mask] + item) / (bins[mask] - item)\\n\\n return scores\",\n \"objective\": 0.05021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by considering the logarithm of the remaining capacity divided by the sum of the bin index and item size, penalizing bins at maximum capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (np.arange(len(bins)) + item))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.05031,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n\\n # Calculate the score for each bin\\n for i in range(len(bins)):\\n if bins[i] != item:\\n scores[i] = 1 / (bins[i] - item)\\n \\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins, set the score to -1 for bins with rest capacity equal to the maximum capacity, and for the remaining feasible bins, set the score to a value inversely proportional to the remaining capacity, and return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = -1\\n scores[bins != max_capacity] = 1 / remaining_capacity[bins != max_capacity]\\n \\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.sort(bins) # sort the array in ascending order\\n scores = np.zeros_like(capacities) # initialize scores array\\n \\n # calculate scores for each bin\\n for i, capacity in enumerate(capacities):\\n if capacity == item: # if rest capacity equals item size, set score to -1\\n scores[i] = -1\\n else:\\n scores[i] = 1 / (capacity - item) # calculate score as the inverse of remaining capacity\\n \\n return scores\",\n \"objective\": 0.05232,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the sum of the rest capacity and the inverse of the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + 1) / (np.arange(bins.size) + 1)\\n scores[bins == item] = 0\\n return scores\",\n \"objective\": 0.05343,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on both the rest capacity and the inverse of the bin number, using a modified weighting factor, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins/item) + (1/(np.arange(1, len(bins)+1))) * 1000\\n scores[bins == item] = 0\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: The score function will assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and the ratio of remaining capacity to item size, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n distances = np.abs(bins - item)\\n scores = (bins * ratios) / distances\\n \\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm 6 (Reverse Ratio): The score function assigns scores to each bin based on the inverse of the ratio between the item size and the bin's remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[np.where(bins == max(bins))] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the sum of the rest capacity and the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n index = np.arange(len(bins))\\n scores = 1 / (rest_capacity + index)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: item (size of the item to be assigned), bins (a list of bin capacities).\\nNew algorithm: The new algorithm assigns scores to bins based on the square root of the item size multiplied by the remaining capacity, the bin number squared, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithm.\\nMain steps: Compute the remaining capacity of each bin, calculate the square root of the item size multiplied by the remaining capacity, compute the square of the bin numbers, calculate the inverse of the remaining capacity, sum up the three calculated values, and return the scores for each bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n sqrt_item_capacity = np.sqrt(item * remaining_capacity)\\n bin_number_squared = np.power(np.arange(len(bins)), 2)\\n inverse_remaining_capacity = 1 / remaining_capacity\\n scores = sqrt_item_capacity + bin_number_squared + inverse_remaining_capacity\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the logarithm (base 2) of the bin index plus one, and return the scores for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log2(np.arange(1, len(bins)+1) + 1))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size and the bin number, subtracting the sum of the remaining capacity and the square root of the item size, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.arange(1, len(bins)+1)) - (np.sqrt(item) + bins)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins - item) != np.max(bins)).astype(int)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on certain criteria and choose the bin with the highest score for item assignment.}\\n\\n{New Algorithm: Assign scores to bins based on the exponential decay of the remaining capacity divided by the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(-bins/item))/(np.sqrt(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"M\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[bins != np.max(bins)] = (np.max(bins) - bins[bins != np.max(bins)]) / item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin by taking the product of the rest capacity and the inverse of the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(bins, np.reciprocal(np.arange(1, len(bins)+1, dtype=float)))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: Assign scores to bins based on the sum of the item size multiplied by the remaining capacity, the bin number squared, and the inverse of the remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of item sizes multiplied by remaining capacity\\n sum_sizes = bins * (item + bins)\\n \\n # Calculate the bin number squared\\n bin_numbers = np.arange(1, len(bins) + 1) ** 2\\n \\n # Calculate the inverse of remaining capacity\\n inv_capacities = 1 / bins\\n \\n # Calculate the scores for each bin\\n scores = sum_sizes + bin_numbers + inv_capacities\\n \\n return scores\",\n \"objective\": 0.04467,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by dividing the square root of the remaining capacity by the sum of the bin index and the item size, penalizing bins at maximum capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.arange(len(bins)) + item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04608,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the absolute difference between the item size and the square of the bin index, divided by the remaining capacity of the bin, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = np.abs(item - bin_indices**2) / bins\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the logarithm of the product of the item and the square root of the bin index, subtracting the sum of the remaining capacity and the exponential decay of the bin index divided by the item size, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_cap = max(bins)\\n\\n scores = np.log(item * np.sqrt(np.arange(len(bins)))) - (np.sum(bins) + np.exp(np.arange(len(bins))) / item)\\n scores[bins == max_cap] = float('-inf')\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by considering the sum of the bin index and item size divided by the remaining capacity of the bin, penalizing bins at maximum capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = (bins[mask] + item) / (bins[mask] - item)\\n\\n return scores\",\n \"objective\": 0.05021,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: The score function will assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and the ratio of remaining capacity to item size, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n distances = np.abs(bins - item)\\n scores = (bins * ratios) / distances\\n \\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm 6 (Reverse Ratio): The score function assigns scores to each bin based on the inverse of the ratio between the item size and the bin's remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[np.where(bins == max(bins))] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: item (size of the item to be assigned), bins (a list of bin capacities).\\nNew algorithm: The new algorithm assigns scores to bins based on the square root of the item size multiplied by the remaining capacity, the bin number squared, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithm.\\nMain steps: Compute the remaining capacity of each bin, calculate the square root of the item size multiplied by the remaining capacity, compute the square of the bin numbers, calculate the inverse of the remaining capacity, sum up the three calculated values, and return the scores for each bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n sqrt_item_capacity = np.sqrt(item * remaining_capacity)\\n bin_number_squared = np.power(np.arange(len(bins)), 2)\\n inverse_remaining_capacity = 1 / remaining_capacity\\n scores = sqrt_item_capacity + bin_number_squared + inverse_remaining_capacity\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the logarithm (base 2) of the bin index plus one, and return the scores for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log2(np.arange(1, len(bins)+1) + 1))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on a combination of the remaining capacity, item size, and bin index.\\nNew algorithm: Assign a score to each bin based on the absolute difference between the item size and the logarithm (base 2) of the bin index plus one, divided by the remaining capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(np.log2(np.arange(1, len(bins) + 1)) - np.log2(item + 1)) / bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the bin's remaining capacity and the square root of the bin number, subtracting the product of the item size and the number of items already assigned, ensuring a unique scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item*np.arange(1, len(bins)+1)) + np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size and the bin number, subtracting the sum of the remaining capacity and the square root of the item size, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.arange(1, len(bins)+1)) - (np.sqrt(item) + bins)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins - item) != np.max(bins)).astype(int)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the logarithm of the remaining capacity divided by the cube root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / ((np.arange(len(bins)) + 1) ** (1/3))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on certain criteria and choose the bin with the highest score for item assignment.}\\n\\n{New Algorithm: Assign scores to bins based on the exponential decay of the remaining capacity divided by the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(-bins/item))/(np.sqrt(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the logarithm of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log(np.arange(1, len(bins)+1)) + 1)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin by taking the product of the rest capacity and the inverse of the index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(bins, np.reciprocal(np.arange(1, len(bins)+1, dtype=float)))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: Assign scores to bins based on the sum of the item size multiplied by the remaining capacity, the bin number squared, and the inverse of the remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of item sizes multiplied by remaining capacity\\n sum_sizes = bins * (item + bins)\\n \\n # Calculate the bin number squared\\n bin_numbers = np.arange(1, len(bins) + 1) ** 2\\n \\n # Calculate the inverse of remaining capacity\\n inv_capacities = 1 / bins\\n \\n # Calculate the scores for each bin\\n scores = sum_sizes + bin_numbers + inv_capacities\\n \\n return scores\",\n \"objective\": 0.04467,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on its capacity and other factors such as ratio, index, proximity to item size, or number of items already assigned.}\\n\\n{New Algorithm: The score function will assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and the ratio of remaining capacity to item size, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n distances = np.abs(bins - item)\\n scores = (bins * ratios) / distances\\n \\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm 6 (Reverse Ratio): The score function assigns scores to each bin based on the inverse of the ratio between the item size and the bin's remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the item size raised to the power of the bin index plus one, divided by the remaining capacity squared, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n \\n scores = (item ** bin_index) / (remaining_capacity ** 2)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the remaining capacity divided by the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1)))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm parameters: item (size of the item to be assigned), bins (a list of bin capacities).\\nNew algorithm: The new algorithm assigns scores to bins based on the square root of the item size multiplied by the remaining capacity, the bin number squared, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithm.\\nMain steps: Compute the remaining capacity of each bin, calculate the square root of the item size multiplied by the remaining capacity, compute the square of the bin numbers, calculate the inverse of the remaining capacity, sum up the three calculated values, and return the scores for each bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n sqrt_item_capacity = np.sqrt(item * remaining_capacity)\\n bin_number_squared = np.power(np.arange(len(bins)), 2)\\n inverse_remaining_capacity = 1 / remaining_capacity\\n scores = sqrt_item_capacity + bin_number_squared + inverse_remaining_capacity\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the logarithm (base 2) of the bin index plus one, and return the scores for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log2(np.arange(1, len(bins)+1) + 1))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on a combination of the remaining capacity, item size, and bin index.\\nNew algorithm: Assign a score to each bin based on the absolute difference between the item size and the logarithm (base 2) of the bin index plus one, divided by the remaining capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(np.log2(np.arange(1, len(bins) + 1)) - np.log2(item + 1)) / bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the bin's remaining capacity and the square root of the bin number, subtracting the product of the item size and the number of items already assigned, ensuring a unique scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item*np.arange(1, len(bins)+1)) + np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size and the bin number, subtracting the sum of the remaining capacity and the square root of the item size, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.arange(1, len(bins)+1)) - (np.sqrt(item) + bins)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins - item) != np.max(bins)).astype(int)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size and the inverse of the bin index plus one, divided by the remaining capacity cubed, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (1 / (np.arange(len(bins)) + 1)) / (bins ** 3))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign a score to each bin based on certain criteria and choose the bin with the highest score for item assignment.}\\n\\n{New Algorithm: Assign scores to bins based on the exponential decay of the remaining capacity divided by the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(-bins/item))/(np.sqrt(np.arange(len(bins))+1))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size divided by the remaining capacity squared and the inverse of the bin index plus one, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins**2)) * (1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the logarithm of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log(np.arange(1, len(bins)+1)) + 1)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the square of the bin index plus one, divided by the remaining capacity, ensuring a unique scoring system. Main steps: Calculate the remaining capacity of each bin, compute the product of the item size and the inverse of the square of the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n index = np.arange(len(bins))\\n scores = (item * (1 / ((index**2) + 1))) / remaining_capacity\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm 6 (Reverse Ratio): The score function assigns scores to each bin based on the inverse of the ratio between the item size and the bin's remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the item size raised to the power of the bin index plus one, divided by the remaining capacity squared, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n \\n scores = (item ** bin_index) / (remaining_capacity ** 2)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the inverse of the ratio of the item size to the remaining capacity, the square of the bin number, and the ratio of the remaining capacity to the item size, ensuring a different scoring system than the existing algorithm while aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.square(np.arange(1, bins.size + 1))) * ((bins - item) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the log of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.arange(1, len(bins) + 1) + 1)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on a combination of the remaining capacity, item size, and bin index.\\nNew algorithm: Assign a score to each bin based on the absolute difference between the item size and the logarithm (base 2) of the bin index plus one, divided by the remaining capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(np.log2(np.arange(1, len(bins) + 1)) - np.log2(item + 1)) / bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the bin's remaining capacity and the square root of the bin number, subtracting the product of the item size and the number of items already assigned, ensuring a unique scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item*np.arange(1, len(bins)+1)) + np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size and the bin number, subtracting the sum of the remaining capacity and the square root of the item size, ensuring a distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.arange(1, len(bins)+1)) - (np.sqrt(item) + bins)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size divided by the remaining capacity raised to the power of the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the product of the item size and the inverse of the bin index plus one, divided by the remaining capacity cubed, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (1 / (np.arange(len(bins)) + 1)) / (bins ** 3))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the square root of the item size to the remaining capacity, multiplied by the inverse of the bin index plus one, and return the scores for assignment. The main steps are to calculate the remaining capacity of each bin, compute the ratio of the square root of the item size to the remaining capacity, multiply it by the inverse of the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item # calculate remaining capacity of each bin\\n sqrt_ratio = np.sqrt(item) / remaining_capacity # ratio of square root of item size to remaining capacity\\n inverse_bin_index = 1 / (np.arange(len(bins)) + 1) # inverse of bin index plus one\\n scores = sqrt_ratio * inverse_bin_index # compute scores for each bin\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the bin index plus one, divided by the remaining capacity raised to the power of two, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (np.arange(len(bins)) + 1)) /\\n (bins - item + 1) ** 2).astype(np.float64)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm 6 (Reverse Ratio): The score function assigns scores to each bin based on the inverse of the ratio between the item size and the bin's remaining capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the remaining capacity to the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the inverse of the ratio of the item size to the remaining capacity, the square of the bin number, and the ratio of the remaining capacity to the item size, ensuring a different scoring system than the existing algorithm while aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.square(np.arange(1, bins.size + 1))) * ((bins - item) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the square root of the remaining capacity and the logarithm (base 10) of the item size multiplied by the bin index plus one, divided by the item size, ensuring a distinct scoring system. Main steps: Compute the remaining capacity of each bin, calculate the square root of the remaining capacity, compute the logarithm (base 10) of the item size, multiply it by the bin index plus one, calculate the absolute difference between the two values, divide it by the item size, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the square root of the remaining capacity\\n sqrt_capacity = np.sqrt(remaining_capacity)\\n \\n # Compute the logarithm (base 10) of the item size\\n log_item = np.log10(item)\\n \\n # Multiply it by the bin index plus one\\n index_plus_one = np.arange(len(bins)) + 1\\n multiplied = log_item * index_plus_one\\n \\n # Calculate the absolute difference between the two values\\n abs_diff = np.abs(sqrt_capacity - multiplied)\\n \\n # Divide it by the item size\\n scores = abs_diff / item\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the log of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.arange(1, len(bins) + 1) + 1)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on a combination of the remaining capacity, item size, and bin index.\\nNew algorithm: Assign a score to each bin based on the absolute difference between the item size and the logarithm (base 2) of the bin index plus one, divided by the remaining capacity, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(np.log2(np.arange(1, len(bins) + 1)) - np.log2(item + 1)) / bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T&C2T2C/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins % item\\n scores[scores == 0] = item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the remainder of each bin's capacity divided by the item's size, substituting zero scores with the item's size and returns an array of scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == item, item, bins % item)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the ratio of the remaining capacity to the item size, the bin number, and the inverse of the remaining capacity, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio = remaining_capacity / item\\n bin_number = np.arange(len(bins))\\n inverse_capacity = 1 / remaining_capacity\\n scores = ratio + bin_number + inverse_capacity\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the inverse of the remaining capacity, subtracting the logarithm of the bin number plus one, ensuring a unique scoring system. Main steps: Compute the remaining capacity of each bin, calculate the product of the item size and the inverse of the remaining capacity, subtract the logarithm of the bin number plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = item * (1 / remaining_capacities) - np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the square root of the item size to the remaining capacity, multiplied by the inverse of the bin index plus one, and return the scores for assignment. The main steps are to calculate the remaining capacity of each bin, compute the ratio of the square root of the item size to the remaining capacity, multiply it by the inverse of the bin index plus one, and return the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item # calculate remaining capacity of each bin\\n sqrt_ratio = np.sqrt(item) / remaining_capacity # ratio of square root of item size to remaining capacity\\n inverse_bin_index = 1 / (np.arange(len(bins)) + 1) # inverse of bin index plus one\\n scores = sqrt_ratio * inverse_bin_index # compute scores for each bin\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the ratio of the logarithm (base 3) of the item size to the remaining capacity, multiplied by the inverse of the square root of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (np.log(3) * (bins - item)) * (1 / np.sqrt(np.arange(bins.size) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the bin index plus one, divided by the remaining capacity raised to the power of two, ensuring a unique and distinct scoring system from the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (np.arange(len(bins)) + 1)) /\\n (bins - item + 1) ** 2).astype(np.float64)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the sum of the item size divided by the remaining capacity, multiplied by the index squared, and penalize bins at maximum capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (item / remaining_capacities) * (np.arange(len(bins)) ** 2)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main algorithm parameter is the item size, bins capacity, and the scoring function which assigns scores to each bin based on the exponential of the sum of the item size and remaining capacity divided by the bin index plus one. \\nFor the new algorithm, we will modify the scoring function to assign scores based only on the remaining capacity of the bins, without considering the item size, using an inverse exponential function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/(item+1))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the square root of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / np.sqrt(np.arange(len(bins)) + 2))\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the difference between the item size and the logarithm (base 10) of the bin index plus one, divided by the remaining capacity, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item - np.log10(np.arange(1, len(bins)+1))) / bins).astype(np.float32)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus two, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 2)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square root of the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign scores to bins based on the inverse of the remaining capacity divided by the bin index plus one, returning the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item + 1)) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the inverse ratio of the bin index plus one to the remaining capacity raised to the power of three, ensuring a modified scoring system that prioritizes filling smaller capacity bins first, while still considering the uniqueness and distinctness of the scoring system in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n \\n # Calculate scores based on the inverse ratio of bin index\\n scores = 1.0 / (np.arange(len(bins)) + 1)\\n \\n # Raise the remaining capacity of each bin to the power of three\\n scores *= np.power(bins, 3)\\n \\n # Disable bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0.0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign scores to bins based on the quotient of the item size divided by the remaining capacity plus one raised to the power of the bin index plus one, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + 1)) ** (np.arange(len(bins)) + 1) # Compute scores for bins\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the sum of the remaining capacity and bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the inverse of the ratio of the item size to the remaining capacity, the square of the bin number, and the ratio of the remaining capacity to the item size, ensuring a different scoring system than the existing algorithm while aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * (np.square(np.arange(1, bins.size + 1))) * ((bins - item) / item)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the exponential of the sum of the item size and the remaining capacity, divided by the bin index plus one, without excluding any bins based on maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((item + bins) / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the sum of the rest capacity divided by the item size, considering all bins regardless of their capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins / item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"assign item to bin with maximum score based on rest capacity}). \\n\\nBased on this idea, the new algorithm assigns the item to the bin with the maximum score calculated by considering the rest capacity, the inverse of the bin number, and a weighted average of the rest capacity and the inverse of the bin number ({assign item to bin with maximum score based on rest capacity, bin number, and weighted average\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.amax(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] / max_capacity) + (1 / (i+1))\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the highest score calculated by taking the square root of the rest capacity multiplied by the reciprocal of the bin number, with a penalty for bins at maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacity\\n sqrt_rest_capacity = np.sqrt(bins)\\n \\n # Calculate the reciprocal of the bin number\\n reciprocal_bin_number = 1 / np.arange(1, len(bins) + 1)\\n \\n # Calculate the score for each bin\\n scores = sqrt_rest_capacity * reciprocal_bin_number\\n \\n # Apply penalty for bins at maximum capacity\\n max_capacity_indices = bins == np.max(bins)\\n scores[max_capacity_indices] -= 0.1\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the bin number and the ratio between the rest capacity and the item size, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_num = np.arange(1, len(bins)+1)\\n ratios = bins / item\\n scores = np.divide(1, bin_num) * ratios\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the inverse of the bin number, the logarithm of the rest capacity, and the ratio between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.arange(1, len(bins)+1)) * np.log(bins) * (bins / item)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign item to bin based on a score function.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the average rest capacity and prioritize bins with higher average rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=int)\\n avg_rest_capacity = np.mean(bins)\\n diff_rest_capacity = bins - avg_rest_capacity\\n scores[diff_rest_capacity > 0] = diff_rest_capacity[diff_rest_capacity > 0]\\n return scores\",\n \"objective\": 0.05322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the scores for each bin by taking the floor of the rest capacity divided by the item size, ignoring bins where the rest capacity equals the maximum capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.floor(bins / item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the product of the inverse of the bin number and the ratio between the remaining capacity and the item size, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins)+1)\\n remaining_capacity = bins - item\\n scores = (1/bin_nums) * (remaining_capacity / item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.06439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign item to bin based on a score function.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the product of the rest capacity squared and the cosine of the bin number, prioritizing bins with higher rest capacity and lower bin numbers, and return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins**2) * np.cos(np.arange(len(bins)))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.07868,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin based on the square root of the rest capacity, multiplied by the sine of the bin number, prioritizing bins with higher rest capacity and lower bin numbers, and return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) * np.sin(np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.0816,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins.max() - item))**(1/3) * np.log(1 / (bins / item)) * (np.arange(len(bins)) + 1)**(1/3)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on the product of the inverse of the bin's rest capacity and the logarithm of the sum of the bin number and the item size, aiming to prioritize bins with lower rest capacity and higher bin numbers while considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log(item + np.arange(1,len(bins)+1))\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number multiplied by a constant factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + bins.sum() + np.arange(len(bins)) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the bin's rest capacity to the square root of the bin number multiplied by a factor, and select the bin with the maximum score for assignment, aiming to prioritize bins with both lower rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * item\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and the difference between the maximum capacity and the rest capacity of the bin, giving higher priority to bins with higher bin numbers, lower rest capacities, and larger differences between maximum and rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n bin_numbers = np.arange(len(bins)) # bin numbers from 0 to len(bins)-1\\n\\n # Calculate scores for each bin\\n scores = bin_numbers + (max_capacity - bins) - bins / max_capacity\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with lower bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_number_score = bins.size - np.arange(bins.size)\\n rest_capacity_score = bins.min() - bins\\n weighted_average_score = (item + bins) / 2\\n scores = bin_number_score + rest_capacity_score + weighted_average_score\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with lower rest capacities, lower bin numbers, and higher item-size-to-rest-capacity ratios.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n ratios = item / bins\\n scores = bin_numbers + ratios\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n item_size_to_rest_capacity = item / (bins - item)\\n scores = bins + bin_numbers + item_size_to_rest_capacity\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins.max() - item))**(1/3) * np.log(1 / (bins / item)) * (np.arange(len(bins)) + 1)**(1/3)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, lower bin numbers, and higher item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n ratios = item / (bins - item)\\n \\n scores = (bins == np.max(bins)) * -1 + bin_numbers * 0.1 + ratios * 0.01\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on the product of the inverse of the bin's rest capacity and the logarithm of the sum of the bin number and the item size, aiming to prioritize bins with lower rest capacity and higher bin numbers while considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log(item + np.arange(1,len(bins)+1))\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number multiplied by a constant factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + bins.sum() + np.arange(len(bins)) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the bin's rest capacity to the square root of the bin number multiplied by a factor, and select the bin with the maximum score for assignment, aiming to prioritize bins with both lower rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * item\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and the difference between the maximum capacity and the rest capacity of the bin, giving higher priority to bins with higher bin numbers, lower rest capacities, and larger differences between maximum and rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n bin_numbers = np.arange(len(bins)) # bin numbers from 0 to len(bins)-1\\n\\n # Calculate scores for each bin\\n scores = bin_numbers + (max_capacity - bins) - bins / max_capacity\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with lower bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_number_score = bins.size - np.arange(bins.size)\\n rest_capacity_score = bins.min() - bins\\n weighted_average_score = (item + bins) / 2\\n scores = bin_number_score + rest_capacity_score + weighted_average_score\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n item_size_to_rest_capacity = item / (bins - item)\\n scores = bins + bin_numbers + item_size_to_rest_capacity\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins.max() - item))**(1/3) * np.log(1 / (bins / item)) * (np.arange(len(bins)) + 1)**(1/3)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, lower bin numbers, and higher item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n ratios = item / (bins - item)\\n \\n scores = (bins == np.max(bins)) * -1 + bin_numbers * 0.1 + ratios * 0.01\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on the product of the inverse of the bin's rest capacity and the logarithm of the sum of the bin number and the item size, aiming to prioritize bins with lower rest capacity and higher bin numbers while considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log(item + np.arange(1,len(bins)+1))\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number multiplied by a constant factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + bins.sum() + np.arange(len(bins)) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the bin's rest capacity to the square root of the bin number multiplied by a factor, and select the bin with the maximum score for assignment, aiming to prioritize bins with both lower rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * item\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and the difference between the maximum capacity and the rest capacity of the bin, giving higher priority to bins with higher bin numbers, lower rest capacities, and larger differences between maximum and rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n bin_numbers = np.arange(len(bins)) # bin numbers from 0 to len(bins)-1\\n\\n # Calculate scores for each bin\\n scores = bin_numbers + (max_capacity - bins) - bins / max_capacity\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with lower bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_number_score = bins.size - np.arange(bins.size)\\n rest_capacity_score = bins.min() - bins\\n weighted_average_score = (item + bins) / 2\\n scores = bin_number_score + rest_capacity_score + weighted_average_score\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n item_size_to_rest_capacity = item / (bins - item)\\n scores = bins + bin_numbers + item_size_to_rest_capacity\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins.max() - item))**(1/3) * np.log(1 / (bins / item)) * (np.arange(len(bins)) + 1)**(1/3)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) * np.sqrt(bins / item))\\n \\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the bin number divided by the item size, prioritizing bins with higher rest capacity, lower bin numbers, and higher item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * np.arange(1, len(bins)+1) / item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, lower bin numbers, and higher item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n ratios = item / (bins - item)\\n \\n scores = (bins == np.max(bins)) * -1 + bin_numbers * 0.1 + ratios * 0.01\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on the product of the inverse of the bin's rest capacity and the logarithm of the sum of the bin number and the item size, aiming to prioritize bins with lower rest capacity and higher bin numbers while considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log(item + np.arange(1,len(bins)+1))\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number multiplied by a constant factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + bins.sum() + np.arange(len(bins)) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity minus the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) * np.sqrt(bins / item))\\n \\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the bin number divided by the item size, prioritizing bins with higher rest capacity, lower bin numbers, and higher item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * np.arange(1, len(bins)+1) / item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, lower bin numbers, and higher item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n ratios = item / (bins - item)\\n \\n scores = (bins == np.max(bins)) * -1 + bin_numbers * 0.1 + ratios * 0.01\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on the product of the inverse of the bin's rest capacity and the logarithm of the sum of the bin number and the item size, aiming to prioritize bins with lower rest capacity and higher bin numbers while considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log(item + np.arange(1,len(bins)+1))\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the cube root of the ratio between the item size and the rest capacity, and the logarithm base 10 of the product of the bin number and the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n max_capacity = np.max(rest_capacity) # maximum capacity among the bins\\n \\n scores = np.zeros(num_bins) # initialize scores array\\n \\n for i in range(num_bins):\\n if rest_capacity[i] == max_capacity:\\n scores[i] = -1 # set score to -1 if bin has maximum capacity\\n else:\\n score1 = rest_capacity[i] / np.sqrt(i+1) # score based on rest capacity divided by square root of bin number\\n score2 = (item / rest_capacity[i])**(1/3) # score based on cube root of item size divided by rest capacity\\n score3 = np.log10((i+1) * (rest_capacity[i] / item)) # score based on logarithm of bin number times ratio of bin capacity to item size\\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity minus the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) * np.sqrt(bins / item))\\n \\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the bin number divided by the item size, prioritizing bins with higher rest capacity, lower bin numbers, and higher item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * np.arange(1, len(bins)+1) / item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, lower bin numbers, and higher item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n ratios = item / (bins - item)\\n \\n scores = (bins == np.max(bins)) * -1 + bin_numbers * 0.1 + ratios * 0.01\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the cube root of the bin number, the logarithm base 2 of the ratio between the item size and the rest capacity, and the product of the square root of the bin number and the inverse of the square of the item size, prioritizing bins with higher rest capacity and bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log2(item / bins) * (np.sqrt(np.arange(1, len(bins)+1)) / (item**2))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the cube root of the ratio between the item size and the rest capacity, and the logarithm base 10 of the product of the bin number and the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n max_capacity = np.max(rest_capacity) # maximum capacity among the bins\\n \\n scores = np.zeros(num_bins) # initialize scores array\\n \\n for i in range(num_bins):\\n if rest_capacity[i] == max_capacity:\\n scores[i] = -1 # set score to -1 if bin has maximum capacity\\n else:\\n score1 = rest_capacity[i] / np.sqrt(i+1) # score based on rest capacity divided by square root of bin number\\n score2 = (item / rest_capacity[i])**(1/3) # score based on cube root of item size divided by rest capacity\\n score3 = np.log10((i+1) * (rest_capacity[i] / item)) # score based on logarithm of bin number times ratio of bin capacity to item size\\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity minus the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) * np.sqrt(bins / item))\\n \\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the bin number divided by the item size, prioritizing bins with higher rest capacity, lower bin numbers, and higher item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * np.arange(1, len(bins)+1) / item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the inverse of the bin number and the square of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n rest_capacity = capacity - item\\n bin_number = i + 1\\n ratio = rest_capacity / item\\n scores[i] = rest_capacity / (bin_number**2) + np.log(1 / ratio) + (1 / bin_number) * (capacity/item)**2\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the cube root of the ratio between the item size and the rest capacity, and the logarithm base 10 of the product of the bin number and the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n max_capacity = np.max(rest_capacity) # maximum capacity among the bins\\n \\n scores = np.zeros(num_bins) # initialize scores array\\n \\n for i in range(num_bins):\\n if rest_capacity[i] == max_capacity:\\n scores[i] = -1 # set score to -1 if bin has maximum capacity\\n else:\\n score1 = rest_capacity[i] / np.sqrt(i+1) # score based on rest capacity divided by square root of bin number\\n score2 = (item / rest_capacity[i])**(1/3) # score based on cube root of item size divided by rest capacity\\n score3 = np.log10((i+1) * (rest_capacity[i] / item)) # score based on logarithm of bin number times ratio of bin capacity to item size\\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity minus the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) * np.sqrt(bins / item))\\n \\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the bin number divided by the item size, prioritizing bins with higher rest capacity, lower bin numbers, and higher item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * np.arange(1, len(bins)+1) / item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1))) * np.log(item / bins) * (np.arange(1, len(bins) + 1) * np.cbrt(bins / item))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the cube root of the ratio between the item size and the rest capacity, and the logarithm base 10 of the product of the bin number and the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n max_capacity = np.max(rest_capacity) # maximum capacity among the bins\\n \\n scores = np.zeros(num_bins) # initialize scores array\\n \\n for i in range(num_bins):\\n if rest_capacity[i] == max_capacity:\\n scores[i] = -1 # set score to -1 if bin has maximum capacity\\n else:\\n score1 = rest_capacity[i] / np.sqrt(i+1) # score based on rest capacity divided by square root of bin number\\n score2 = (item / rest_capacity[i])**(1/3) # score based on cube root of item size divided by rest capacity\\n score3 = np.log10((i+1) * (rest_capacity[i] / item)) # score based on logarithm of bin number times ratio of bin capacity to item size\\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity minus the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) * np.sqrt(bins / item))\\n \\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the bin number divided by the item size, prioritizing bins with higher rest capacity, lower bin numbers, and higher item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * np.arange(1, len(bins)+1) / item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins) + 1))) * np.log(item / bins) * (np.arange(1, len(bins) + 1) * np.cbrt(bins / item))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the difference between the bin number and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and larger differences between the bin number and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(np.arange(1, len(bins)+1))) * (np.log(item / bins)) * (np.abs(np.arange(1, len(bins)+1) - item))\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the cosine of the bin's rest capacity divided by the square root of the bin number, multiplied by the inverse of the sum of the item size and the rest capacity, to prioritize bins with higher rest capacity and lower bin numbers while considering the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n bin_numbers = np.arange(1, len(bins)+1)\\n scores = np.cos(rest_capacity / np.sqrt(bin_numbers)) * (1 / (item + rest_capacity))\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the cube root of the ratio between the item size and the rest capacity, and the logarithm base 10 of the product of the bin number and the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n max_capacity = np.max(rest_capacity) # maximum capacity among the bins\\n \\n scores = np.zeros(num_bins) # initialize scores array\\n \\n for i in range(num_bins):\\n if rest_capacity[i] == max_capacity:\\n scores[i] = -1 # set score to -1 if bin has maximum capacity\\n else:\\n score1 = rest_capacity[i] / np.sqrt(i+1) # score based on rest capacity divided by square root of bin number\\n score2 = (item / rest_capacity[i])**(1/3) # score based on cube root of item size divided by rest capacity\\n score3 = np.log10((i+1) * (rest_capacity[i] / item)) # score based on logarithm of bin number times ratio of bin capacity to item size\\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the square root of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) * np.sqrt(bins / item))\\n \\n max_capacity = np.max(bins)\\n \\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the bin number divided by the item size, prioritizing bins with higher rest capacity, lower bin numbers, and higher item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * np.arange(1, len(bins)+1) / item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the logarithm of the bin number, the inverse of the rest capacity, and the ratio between the item size and the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1)\\n capacities = bins - item\\n ratios = item / capacities\\n \\n scores = np.log(bin_nums) * (1 / capacities) * ratios\\n scores[bins == max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of weighted averages of bin rest capacity, the inverse of the bin number, and the square root of the bin capacity, prioritizing bins with higher rest capacity, lower bin numbers, and higher bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (\\n (bins.max() - bins) / bins.max() + # weighted average of bin rest capacity\\n 1 / (np.arange(len(bins)) + 1) + # weighted average of inverse of bin number\\n np.sqrt(bins.max() - bins) # weighted average of square root of bin capacity\\n )\\n # Set scores of bins with capacity equal to maximum capacity to -inf\\n scores[bins == bins.max()] = float('-inf')\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the sum of the rest capacity divided by the item size, considering all bins regardless of their capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins / item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"assign item to bin with maximum score based on rest capacity}). \\n\\nBased on this idea, the new algorithm assigns the item to the bin with the maximum score calculated by considering the rest capacity, the inverse of the bin number, and a weighted average of the rest capacity and the inverse of the bin number ({assign item to bin with maximum score based on rest capacity, bin number, and weighted average\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.amax(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] / max_capacity) + (1 / (i+1))\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of the rest capacity to the bin number, prioritizing bins with higher rest capacity and lower bin numbers for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the product of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n score = item / (bins[i] * (i+1))\\n scores[i] = score\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the rest capacity and the inverse of the bin number to prioritize bins with both high rest capacity and lower bin numbers for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = bins * (1 / np.arange(1, len(bins)+1))\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the inverse of the bin number, the logarithm of the rest capacity, and the ratio between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.arange(1, len(bins)+1)) * np.log(bins) * (bins / item)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the ratio between the logarithm of the bin number and the rest capacity multiplied by a factor that represents the bin's utilization trend, aiming to optimize bin utilization and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_trend_factor = 0.5\\n\\n # Calculate the logarithm of bin numbers\\n bin_numbers = np.log10(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio between logarithm of bin numbers and the rest capacity\\n ratios = bin_numbers / bins\\n\\n # Calculate the scores for bins\\n scores = ratios * utilization_trend_factor\\n\\n # Set the scores of unused bins to a very low value (-inf)\\n unused_bins_mask = bins == bins.max()\\n scores[unused_bins_mask] = float('-inf')\\n\\n return scores\",\n \"objective\": 0.04829,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the square root of the rest capacity multiplied by the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) * (1 / np.arange(1, len(bins) + 1))\\n scores[bins == item] = -np.inf\\n return scores\",\n \"objective\": 0.05252,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to bin with the maximum score based on the product of the inverse square root of the rest capacity, the logarithm of the bin number, and a random factor, aiming to increase the diversity of bin assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.sqrt(bins)) * np.log(np.arange(1, len(bins) + 1))\\n scores = np.multiply(scores, np.random.uniform(0.9, 1.1, len(bins)))\\n scores[bins - item == 0] = 0\\n return scores\",\n \"objective\": 0.05272,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign item to bin based on a score function.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the average rest capacity and prioritize bins with higher average rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=int)\\n avg_rest_capacity = np.mean(bins)\\n diff_rest_capacity = bins - avg_rest_capacity\\n scores[diff_rest_capacity > 0] = diff_rest_capacity[diff_rest_capacity > 0]\\n return scores\",\n \"objective\": 0.05322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign item to bin with the maximum score based on the combination of rest capacity, bin number, and a weighted average of the rest capacity and the inverse of the bin number, prioritizing bins with lower rest capacity, higher bin numbers, and higher weighted average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n weighted_average = bins / (bins.sum() + 1e-16)\\n scores = bins * (weighted_average + 1 / bin_numbers)\\n scores[bins == item] = 0\\n return scores\",\n \"objective\": 0.05363,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the logarithm of the rest capacity, the inverse of the bin number, and a weighting factor, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) * (1 / (np.arange(len(bins)) + 1))\\n scores[bins == item] = -np.inf\\n return scores\",\n \"objective\": 0.05373,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number squared, the inverse of the item size, and the logarithm of the ratio between the item size and the rest capacity, prioritizing bins with higher rest capacity, smaller bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1)**2 * item * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the difference between the bin number and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and larger differences between the bin number and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(np.arange(1, len(bins)+1))) * (np.log(item / bins)) * (np.abs(np.arange(1, len(bins)+1) - item))\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the bin's rest capacity divided by the square root of the bin number, the ratio between the item size and the rest capacity squared, and the exponential of the negative reciprocal of the ratio between the bin capacity and the item size cubed, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Calculate bin numbers\\n rest_capacities = bins - item # Calculate rest capacities of bins\\n \\n # Calculate scores for each bin\\n scores = rest_capacities / np.sqrt(bin_nums) # Rest capacity divided by square root of bin number\\n scores *= (item / rest_capacities**2) # Ratio between item size and rest capacity squared\\n scores *= np.exp(-1 / (bins / item**3)) # Exponential of negative reciprocal of ratio between bin capacity and item size cubed\\n \\n # Set scores of bins with maximum capacity to zero\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the cosine of the bin's rest capacity divided by the square root of the bin number, multiplied by the inverse of the sum of the item size and the rest capacity, to prioritize bins with higher rest capacity and lower bin numbers while considering the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n bin_numbers = np.arange(1, len(bins)+1)\\n scores = np.cos(rest_capacity / np.sqrt(bin_numbers)) * (1 / (item + rest_capacity))\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the bin capacity and the item size, prioritizing larger rest capacity, lower bin numbers, and smaller item sizes, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n item_sizes = np.full_like(bins, item)\\n \\n scores = (bins * np.sqrt(bin_numbers)) / np.log(bin_capacity_ratios)\\n scores[bins == np.max(bins)] = -np.inf\\n scores[item_sizes > bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the cube root of the ratio between the item size and the rest capacity, and the logarithm base 10 of the product of the bin number and the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n max_capacity = np.max(rest_capacity) # maximum capacity among the bins\\n \\n scores = np.zeros(num_bins) # initialize scores array\\n \\n for i in range(num_bins):\\n if rest_capacity[i] == max_capacity:\\n scores[i] = -1 # set score to -1 if bin has maximum capacity\\n else:\\n score1 = rest_capacity[i] / np.sqrt(i+1) # score based on rest capacity divided by square root of bin number\\n score2 = (item / rest_capacity[i])**(1/3) # score based on cube root of item size divided by rest capacity\\n score3 = np.log10((i+1) * (rest_capacity[i] / item)) # score based on logarithm of bin number times ratio of bin capacity to item size\\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the square root of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number squared, the inverse of the item size, and the logarithm of the ratio between the item size and the rest capacity, prioritizing bins with higher rest capacity, smaller bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1)**2 * item * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the difference between the bin number and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and larger differences between the bin number and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(np.arange(1, len(bins)+1))) * (np.log(item / bins)) * (np.abs(np.arange(1, len(bins)+1) - item))\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the bin's rest capacity divided by the square root of the bin number, the ratio between the item size and the rest capacity squared, and the exponential of the negative reciprocal of the ratio between the bin capacity and the item size cubed, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Calculate bin numbers\\n rest_capacities = bins - item # Calculate rest capacities of bins\\n \\n # Calculate scores for each bin\\n scores = rest_capacities / np.sqrt(bin_nums) # Rest capacity divided by square root of bin number\\n scores *= (item / rest_capacities**2) # Ratio between item size and rest capacity squared\\n scores *= np.exp(-1 / (bins / item**3)) # Exponential of negative reciprocal of ratio between bin capacity and item size cubed\\n \\n # Set scores of bins with maximum capacity to zero\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the cosine of the bin's rest capacity divided by the square root of the bin number, multiplied by the inverse of the sum of the item size and the rest capacity, to prioritize bins with higher rest capacity and lower bin numbers while considering the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n bin_numbers = np.arange(1, len(bins)+1)\\n scores = np.cos(rest_capacity / np.sqrt(bin_numbers)) * (1 / (item + rest_capacity))\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity and larger item sizes, with a penalty for higher bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = rest_capacity / np.log(item / rest_capacity) - i / 1000\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the cube root of the ratio between the item size and the rest capacity, and the logarithm base 10 of the product of the bin number and the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n max_capacity = np.max(rest_capacity) # maximum capacity among the bins\\n \\n scores = np.zeros(num_bins) # initialize scores array\\n \\n for i in range(num_bins):\\n if rest_capacity[i] == max_capacity:\\n scores[i] = -1 # set score to -1 if bin has maximum capacity\\n else:\\n score1 = rest_capacity[i] / np.sqrt(i+1) # score based on rest capacity divided by square root of bin number\\n score2 = (item / rest_capacity[i])**(1/3) # score based on cube root of item size divided by rest capacity\\n score3 = np.log10((i+1) * (rest_capacity[i] / item)) # score based on logarithm of bin number times ratio of bin capacity to item size\\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the square root of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.sqrt(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number squared, the inverse of the item size, and the logarithm of the ratio between the item size and the rest capacity, prioritizing bins with higher rest capacity, smaller bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1)**2 * item * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the division of the rest capacity by the bin number, multiplied by the logarithm of three times the rest capacity, prioritizing bins with higher rest capacity and lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity / np.arange(1, len(rest_capacity) + 1) * np.log(3 * rest_capacity)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the difference between the bin number and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and larger differences between the bin number and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(np.arange(1, len(bins)+1))) * (np.log(item / bins)) * (np.abs(np.arange(1, len(bins)+1) - item))\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the bin's rest capacity divided by the square root of the bin number, the ratio between the item size and the rest capacity squared, and the exponential of the negative reciprocal of the ratio between the bin capacity and the item size cubed, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Calculate bin numbers\\n rest_capacities = bins - item # Calculate rest capacities of bins\\n \\n # Calculate scores for each bin\\n scores = rest_capacities / np.sqrt(bin_nums) # Rest capacity divided by square root of bin number\\n scores *= (item / rest_capacities**2) # Ratio between item size and rest capacity squared\\n scores *= np.exp(-1 / (bins / item**3)) # Exponential of negative reciprocal of ratio between bin capacity and item size cubed\\n \\n # Set scores of bins with maximum capacity to zero\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the cosine of the bin's rest capacity divided by the square root of the bin number, multiplied by the inverse of the sum of the item size and the rest capacity, to prioritize bins with higher rest capacity and lower bin numbers while considering the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n bin_numbers = np.arange(1, len(bins)+1)\\n scores = np.cos(rest_capacity / np.sqrt(bin_numbers)) * (1 / (item + rest_capacity))\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity and larger item sizes, with a penalty for higher bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = rest_capacity / np.log(item / rest_capacity) - i / 1000\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the multiplication of the rest capacity, the square of the inverse of the bin number, and the logarithm of twice the rest capacity, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * (1 / np.square(np.arange(1, len(rest_capacity) + 1))) * np.log(2 * rest_capacity)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the cube root of the bin number, the logarithm of the ratio between the item size and the rest capacity squared, and the difference between the bin number and the item size divided by the sum of the bin capacity and the item size cubed, prioritizing bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins.copy()\\n rest_capacity[rest_capacity == item] = 0\\n bin_numbers = np.arange(1, len(bins) + 1)\\n \\n score_1 = rest_capacity * np.cbrt(bin_numbers)\\n score_2 = np.log(item / rest_capacity**2)\\n score_3 = (bin_numbers - item) / (bins + item**3)\\n \\n scores = score_1 * score_2 * score_3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number squared, the inverse of the item size, and the logarithm of the ratio between the item size and the rest capacity, prioritizing bins with higher rest capacity, smaller bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1)**2 * item * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the division of the rest capacity by the bin number, multiplied by the logarithm of three times the rest capacity, prioritizing bins with higher rest capacity and lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity / np.arange(1, len(rest_capacity) + 1) * np.log(3 * rest_capacity)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the difference between the bin number and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and larger differences between the bin number and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(np.arange(1, len(bins)+1))) * (np.log(item / bins)) * (np.abs(np.arange(1, len(bins)+1) - item))\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the bin's rest capacity divided by the square root of the bin number, the ratio between the item size and the rest capacity squared, and the exponential of the negative reciprocal of the ratio between the bin capacity and the item size cubed, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Calculate bin numbers\\n rest_capacities = bins - item # Calculate rest capacities of bins\\n \\n # Calculate scores for each bin\\n scores = rest_capacities / np.sqrt(bin_nums) # Rest capacity divided by square root of bin number\\n scores *= (item / rest_capacities**2) # Ratio between item size and rest capacity squared\\n scores *= np.exp(-1 / (bins / item**3)) # Exponential of negative reciprocal of ratio between bin capacity and item size cubed\\n \\n # Set scores of bins with maximum capacity to zero\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the cosine of the bin's rest capacity divided by the square root of the bin number, multiplied by the inverse of the sum of the item size and the rest capacity, to prioritize bins with higher rest capacity and lower bin numbers while considering the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n bin_numbers = np.arange(1, len(bins)+1)\\n scores = np.cos(rest_capacity / np.sqrt(bin_numbers)) * (1 / (item + rest_capacity))\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity and larger item sizes, with a penalty for higher bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = rest_capacity / np.log(item / rest_capacity) - i / 1000\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the multiplication of the rest capacity, the square of the inverse of the bin number, and the logarithm of twice the rest capacity, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * (1 / np.square(np.arange(1, len(rest_capacity) + 1))) * np.log(2 * rest_capacity)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the cube root of the bin number, the logarithm of the ratio between the item size and the rest capacity squared, and the difference between the bin number and the item size divided by the sum of the bin capacity and the item size cubed, prioritizing bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins.copy()\\n rest_capacity[rest_capacity == item] = 0\\n bin_numbers = np.arange(1, len(bins) + 1)\\n \\n score_1 = rest_capacity * np.cbrt(bin_numbers)\\n score_2 = np.log(item / rest_capacity**2)\\n score_3 = (bin_numbers - item) / (bins + item**3)\\n \\n scores = score_1 * score_2 * score_3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number squared, the inverse of the item size, and the logarithm of the ratio between the item size and the rest capacity, prioritizing bins with higher rest capacity, smaller bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1)**2 * item * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the division of the rest capacity by the bin number, multiplied by the logarithm of three times the rest capacity, prioritizing bins with higher rest capacity and lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity / np.arange(1, len(rest_capacity) + 1) * np.log(3 * rest_capacity)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the difference between the bin number and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and larger differences between the bin number and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(np.arange(1, len(bins)+1))) * (np.log(item / bins)) * (np.abs(np.arange(1, len(bins)+1) - item))\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the bin's rest capacity divided by the square root of the bin number, the ratio between the item size and the rest capacity squared, and the exponential of the negative reciprocal of the ratio between the bin capacity and the item size cubed, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Calculate bin numbers\\n rest_capacities = bins - item # Calculate rest capacities of bins\\n \\n # Calculate scores for each bin\\n scores = rest_capacities / np.sqrt(bin_nums) # Rest capacity divided by square root of bin number\\n scores *= (item / rest_capacities**2) # Ratio between item size and rest capacity squared\\n scores *= np.exp(-1 / (bins / item**3)) # Exponential of negative reciprocal of ratio between bin capacity and item size cubed\\n \\n # Set scores of bins with maximum capacity to zero\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the cosine of the bin's rest capacity divided by the square root of the bin number, multiplied by the inverse of the sum of the item size and the rest capacity, to prioritize bins with higher rest capacity and lower bin numbers while considering the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n bin_numbers = np.arange(1, len(bins)+1)\\n scores = np.cos(rest_capacity / np.sqrt(bin_numbers)) * (1 / (item + rest_capacity))\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the bin's rest capacity, bin number, and a custom function that takes into account the item size and the number of items already assigned to the bin, prioritizing bins with higher rest capacities, lower bin numbers, and a lower ratio of already assigned items to rest capacity, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n rest_capacities = bins\\n num_items_assigned = np.maximum(0, bins - item)\\n \\n ratio_assigned_to_capacity = num_items_assigned / (rest_capacities - item)\\n scores = rest_capacities * bin_numbers + ratio_assigned_to_capacity\\n \\n # Set scores of unused bins to a negative infinity value\\n scores[rest_capacities == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the sum of the bin's rest capacity divided by the exponential function of the bin number and the item size, the inverse of the logarithm of the ratio between the rest capacity and item size, and the product of the bin number and the logarithm of the ratio between the bin capacity and item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score_1 = bins[i] / (np.exp(i+1) * item)\\n score_2 = np.log(bins[i] / item)**-1\\n score_3 = (i+1) * np.log(bins[i] / item)\\n \\n scores[i] = score_1 + score_2 + score_3\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity and larger item sizes, with a penalty for higher bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = rest_capacity / np.log(item / rest_capacity) - i / 1000\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin as the ratio of the item size to the rest capacity minus the natural logarithm of the bin number, then return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.log(np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the cube root of the bin number, the logarithm of the ratio between the item size and the rest capacity squared, and the difference between the bin number and the item size divided by the sum of the bin capacity and the item size cubed, prioritizing bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins.copy()\\n rest_capacity[rest_capacity == item] = 0\\n bin_numbers = np.arange(1, len(bins) + 1)\\n \\n score_1 = rest_capacity * np.cbrt(bin_numbers)\\n score_2 = np.log(item / rest_capacity**2)\\n score_3 = (bin_numbers - item) / (bins + item**3)\\n \\n scores = score_1 * score_2 * score_3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number squared, the inverse of the item size, and the logarithm of the ratio between the item size and the rest capacity, prioritizing bins with higher rest capacity, smaller bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1)**2 * item * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the logarithm of the ratio between the item size and the rest capacity, and the absolute difference between the bin number and the item size divided by the sum of the bin capacity and the item size squared, prioritizing bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1)\\n \\n sqrtn_bin_nums = np.sqrt(bin_nums)\\n log_ratio = np.log(item / bins)\\n abs_diff = np.abs(bin_nums - item) / (bins + item**2)\\n \\n scores = bins * sqrtn_bin_nums * log_ratio * abs_diff\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the division of the rest capacity by the bin number, multiplied by the logarithm of three times the rest capacity, prioritizing bins with higher rest capacity and lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity / np.arange(1, len(rest_capacity) + 1) * np.log(3 * rest_capacity)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the sum of the logarithm of the rest capacity, the square root of the bin number, and the reciprocal of the product of the rest capacity and the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and a balanced ratio of rest capacity to bin number, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins\\n rest_capacity[rest_capacity == item] = 0\\n \\n scores = np.log(rest_capacity) + np.sqrt(np.arange(1, len(bins)+1)) + (1 / (rest_capacity * np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.02173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the bin's rest capacity divided by the bin number, the square root of the item size and the exponential function of the difference between the bin number and item size, in order to prioritize bins with higher rest capacities, lower bin numbers and larger differences between the bin number and item size, ultimately minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1) # Generate bin numbers\\n rest_capacities = bins - item # Calculate rest capacities\\n differences = np.abs(bin_numbers - item) # Calculate differences between bin numbers and item size\\n\\n # Calculate scores using the formula\\n scores = rest_capacities / bin_numbers * np.sqrt(item) * np.exp(differences)\\n\\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin's rest capacity and the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the difference between the bin number and the item size, prioritizing bins with higher rest capacity, lower bin numbers, and larger differences between the bin number and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(np.arange(1, len(bins)+1))) * (np.log(item / bins)) * (np.abs(np.arange(1, len(bins)+1) - item))\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity divided by the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the square of the inverse of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins - item\\n \\n score1 = rest_capacities / bin_numbers\\n score2 = np.log(item / rest_capacities)\\n score3 = (1 / (bin_numbers**2)) * (1 / item)\\n \\n scores = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to bins based on their rest capacity, bin number, and a custom function that considers rest capacity, bin number, and item size, in order to prioritize bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios, and then assign the item to the bin with the maximum score while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n ratios = item / (bins - item)\\n scores = bins + bin_nums + ratios\\n scores[bins == np.max(bins)] = np.min(scores)\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the bin's rest capacity and the square root of the bin number, multiplied by the inverse of the item size, aiming to prioritize bins with higher rest capacity and lower bin numbers while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins)+1)\\n rest_capacities = bins.astype(float)\\n rest_capacities[rest_capacities == item] = np.inf\\n \\n scores = np.log(rest_capacities / np.sqrt(bin_numbers)) * (1.0 / item)\\n \\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the bin's rest capacity divided by the square root of the bin number, the ratio between the item size and the rest capacity squared, and the exponential of the negative reciprocal of the ratio between the bin capacity and the item size cubed, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes, excluding bins with maximum capacity, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1) # Calculate bin numbers\\n rest_capacities = bins - item # Calculate rest capacities of bins\\n \\n # Calculate scores for each bin\\n scores = rest_capacities / np.sqrt(bin_nums) # Rest capacity divided by square root of bin number\\n scores *= (item / rest_capacities**2) # Ratio between item size and rest capacity squared\\n scores *= np.exp(-1 / (bins / item**3)) # Exponential of negative reciprocal of ratio between bin capacity and item size cubed\\n \\n # Set scores of bins with maximum capacity to zero\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's rest capacity multiplied by the square root of the bin number, divided by the logarithm of the ratio between the item size and the rest capacity, prioritizing smaller rest capacity, higher bin numbers, and larger item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins*np.sqrt(np.arange(1,len(bins)+1))) / np.log(item/bins)\\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the cosine of the bin's rest capacity divided by the square root of the bin number, multiplied by the inverse of the sum of the item size and the rest capacity, to prioritize bins with higher rest capacity and lower bin numbers while considering the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n bin_numbers = np.arange(1, len(bins)+1)\\n scores = np.cos(rest_capacity / np.sqrt(bin_numbers)) * (1 / (item + rest_capacity))\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the bin's rest capacity, bin number, and a custom function that takes into account the item size and the number of items already assigned to the bin, prioritizing bins with higher rest capacities, lower bin numbers, and a lower ratio of already assigned items to rest capacity, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n rest_capacities = bins\\n num_items_assigned = np.maximum(0, bins - item)\\n \\n ratio_assigned_to_capacity = num_items_assigned / (rest_capacities - item)\\n scores = rest_capacities * bin_numbers + ratio_assigned_to_capacity\\n \\n # Set scores of unused bins to a negative infinity value\\n scores[rest_capacities == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n continue\\n \\n rest_capacity = capacity - item\\n bin_number = i + 1\\n \\n score1 = rest_capacity / np.sqrt(bin_number)\\n score2 = np.log(1/(rest_capacity/item))\\n score3 = bin_number * np.sqrt(capacity/item)\\n \\n scores[i] = score1 + score2 + score3\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the logarithm of the bin number, the inverse of the rest capacity, and the ratio between the item size and the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1)\\n capacities = bins - item\\n ratios = item / capacities\\n \\n scores = np.log(bin_nums) * (1 / capacities) * ratios\\n scores[bins == max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of the ratio of the rest capacity to the bin number and the logarithm of the bin capacity, prioritizing bins with higher rest capacity and lower bin numbers, while also considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacity_ratio = bins / bins.sum()\\n logarithmic_increase = np.log(bins)\\n \\n scores = rest_capacity_ratio * (1/bin_numbers) * logarithmic_increase\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the square root of the rest capacity to the logarithm of the bin number, emphasizing both optimal utilization and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.log(1 + np.arange(1, len(bins) + 1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of weighted averages of bin rest capacity, the inverse of the bin number, and the square root of the bin capacity, prioritizing bins with higher rest capacity, lower bin numbers, and higher bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (\\n (bins.max() - bins) / bins.max() + # weighted average of bin rest capacity\\n 1 / (np.arange(len(bins)) + 1) + # weighted average of inverse of bin number\\n np.sqrt(bins.max() - bins) # weighted average of square root of bin capacity\\n )\\n # Set scores of bins with capacity equal to maximum capacity to -inf\\n scores[bins == bins.max()] = float('-inf')\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the sum of the rest capacity divided by the item size, considering all bins regardless of their capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins / item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"assign item to bin with maximum score based on rest capacity}). \\n\\nBased on this idea, the new algorithm assigns the item to the bin with the maximum score calculated by considering the rest capacity, the inverse of the bin number, and a weighted average of the rest capacity and the inverse of the bin number ({assign item to bin with maximum score based on rest capacity, bin number, and weighted average\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.amax(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] / max_capacity) + (1 / (i+1))\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of the rest capacity to the bin number, prioritizing bins with higher rest capacity and lower bin numbers for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the product of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n score = item / (bins[i] * (i+1))\\n scores[i] = score\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by taking into account the bin number, rest capacity, and a weighted average of the item size and the rest capacity, prioritizing bins with higher bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n num_bins = len(bins)\\n max_capacity = max(bins)\\n \\n for i in range(num_bins):\\n rest_capacity = bins[i]\\n \\n # If rest capacity equals to the maximum capacity, don't use the bin\\n if rest_capacity == max_capacity:\\n continue\\n \\n # Calculate the weighted average score\\n weighted_avg = (item + rest_capacity) / 2\\n \\n # Calculate the bin score based on bin number, rest capacity, and weighted average\\n bin_score = ((num_bins - i) * 100) + ((max_capacity - rest_capacity) * 10) + weighted_avg\\n \\n # Assign the score to the corresponding bin\\n scores[i] = bin_score\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the rest capacity and the inverse of the bin number to prioritize bins with both high rest capacity and lower bin numbers for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = bins * (1 / np.arange(1, len(bins)+1))\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the inverse of the bin number, the logarithm of the rest capacity, and the ratio between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.arange(1, len(bins)+1)) * np.log(bins) * (bins / item)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the ratio between the logarithm of the bin number and the rest capacity multiplied by a factor that represents the bin's utilization trend, aiming to optimize bin utilization and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_trend_factor = 0.5\\n\\n # Calculate the logarithm of bin numbers\\n bin_numbers = np.log10(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio between logarithm of bin numbers and the rest capacity\\n ratios = bin_numbers / bins\\n\\n # Calculate the scores for bins\\n scores = ratios * utilization_trend_factor\\n\\n # Set the scores of unused bins to a very low value (-inf)\\n unused_bins_mask = bins == bins.max()\\n scores[unused_bins_mask] = float('-inf')\\n\\n return scores\",\n \"objective\": 0.04829,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the ratio of item size to rest capacity and the bin number multiplied by a fixed factor, and returns the scores for bin assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) * np.arange(len(bins)) * 2\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.05182,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the square root of the rest capacity multiplied by the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) * (1 / np.arange(1, len(bins) + 1))\\n scores[bins == item] = -np.inf\\n return scores\",\n \"objective\": 0.05252,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign items to bins by calculating a score that is derived from the ratio of the rest capacity to the square root of the product of the bin number and the item size, while prioritizing bins with higher rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(np.arange(1,len(bins)+1)) * item)\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In this new algorithm, only the bins with less than maximum capacity are considered for scoring, unlike the previous algorithm which considered all bins regardless of their capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n feasible_bins = bins[bins < max_capacity]\\n scores[bins < max_capacity] = item / feasible_bins\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of the ratio of the rest capacity to the bin number and the logarithm of the bin capacity, prioritizing bins with higher rest capacity and lower bin numbers, while also considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacity_ratio = bins / bins.sum()\\n logarithmic_increase = np.log(bins)\\n \\n scores = rest_capacity_ratio * (1/bin_numbers) * logarithmic_increase\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with higher bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins\\n weighted_averages = (item + bins) / 2\\n\\n scores = bin_numbers * 100 + rest_capacities + weighted_averages\\n\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the square root of the rest capacity to the logarithm of the bin number, emphasizing both optimal utilization and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.log(1 + np.arange(1, len(bins) + 1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the sum of the rest capacity divided by the item size, the inverse of the bin number, and the logarithm of the ratio between the rest capacity and the item size, while excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.sum() - bins) / item + 1 / np.arange(1, len(bins) + 1) + np.log(bins / item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the sum of the rest capacity divided by the item size, considering all bins regardless of their capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins / item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"assign item to bin with maximum score based on rest capacity}). \\n\\nBased on this idea, the new algorithm assigns the item to the bin with the maximum score calculated by considering the rest capacity, the inverse of the bin number, and a weighted average of the rest capacity and the inverse of the bin number ({assign item to bin with maximum score based on rest capacity, bin number, and weighted average\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.amax(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] / max_capacity) + (1 / (i+1))\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of the rest capacity to the bin number, prioritizing bins with higher rest capacity and lower bin numbers for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for each bin by dividing the inverse of the rest capacity by the product of the bin number and the item size, and assign the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins * np.arange(1, len(bins)+1) * item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by taking into account the bin number, rest capacity, and a weighted average of the item size and the rest capacity, prioritizing bins with higher bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n num_bins = len(bins)\\n max_capacity = max(bins)\\n \\n for i in range(num_bins):\\n rest_capacity = bins[i]\\n \\n # If rest capacity equals to the maximum capacity, don't use the bin\\n if rest_capacity == max_capacity:\\n continue\\n \\n # Calculate the weighted average score\\n weighted_avg = (item + rest_capacity) / 2\\n \\n # Calculate the bin score based on bin number, rest capacity, and weighted average\\n bin_score = ((num_bins - i) * 100) + ((max_capacity - rest_capacity) * 10) + weighted_avg\\n \\n # Assign the score to the corresponding bin\\n scores[i] = bin_score\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the product of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins * np.sqrt(np.arange(1, len(bins) + 1)))\\n scores[bins == bins.max() - item] = 0\\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the bin capacity and the inverse of the bin number to prioritize bins with higher bin capacity and lower bin numbers for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the inverse of the bin number, the logarithm of the rest capacity, and the ratio between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.arange(1, len(bins)+1)) * np.log(bins) * (bins / item)\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign items to bins by calculating a score that is derived from the ratio of the rest capacity to the square root of the product of the bin number and the item size, while prioritizing bins with higher rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(np.arange(1,len(bins)+1)) * item)\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In this new algorithm, only the bins with less than maximum capacity are considered for scoring, unlike the previous algorithm which considered all bins regardless of their capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n feasible_bins = bins[bins < max_capacity]\\n scores[bins < max_capacity] = item / feasible_bins\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of the ratio of the rest capacity to the bin number and the logarithm of the bin capacity, prioritizing bins with higher rest capacity and lower bin numbers, while also considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacity_ratio = bins / bins.sum()\\n logarithmic_increase = np.log(bins)\\n \\n scores = rest_capacity_ratio * (1/bin_numbers) * logarithmic_increase\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with higher bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins\\n weighted_averages = (item + bins) / 2\\n\\n scores = bin_numbers * 100 + rest_capacities + weighted_averages\\n\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the square root of the rest capacity to the logarithm of the bin number, emphasizing both optimal utilization and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.log(1 + np.arange(1, len(bins) + 1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the sum of the rest capacity divided by the item size, the inverse of the bin number, and the logarithm of the ratio between the rest capacity and the item size, while excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.sum() - bins) / item + 1 / np.arange(1, len(bins) + 1) + np.log(bins / item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the sum of the rest capacity divided by the item size, considering all bins regardless of their capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins / item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"assign item to bin with maximum score based on rest capacity}). \\n\\nBased on this idea, the new algorithm assigns the item to the bin with the maximum score calculated by considering the rest capacity, the inverse of the bin number, and a weighted average of the rest capacity and the inverse of the bin number ({assign item to bin with maximum score based on rest capacity, bin number, and weighted average\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.amax(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] / max_capacity) + (1 / (i+1))\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of the rest capacity to the bin number, prioritizing bins with higher rest capacity and lower bin numbers for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for each bin by dividing the inverse of the rest capacity by the product of the bin number and the item size, and assign the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins * np.arange(1, len(bins)+1) * item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin number, rest capacity, and a weighted average of the item size and the rest capacity, prioritizing bins with lower bin numbers, higher rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n rest_capacities = bins\\n weighted_avg = (item + rest_capacities) / rest_capacities\\n scores = -1 * (bin_nums + 1) * (rest_capacities ** 2) * weighted_avg\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the product of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins * np.sqrt(np.arange(1, len(bins) + 1)))\\n scores[bins == bins.max() - item] = 0\\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the ratio of the bin capacity to the item size, the square root of the bin number, and the logarithm of the ratio between the bin capacity and the item size, while excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n b_capacity = bins / item\\n b_number = np.sqrt(np.arange(1, len(bins) + 1))\\n b_ratio = np.log(b_capacity / item)\\n scores = b_capacity * b_number * b_ratio\\n\\n # Exclude bins with maximum capacity\\n max_capacity = max(bins)\\n scores[bins == max_capacity] = -np.inf\\n\\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the bin capacity and the inverse of the bin number to prioritize bins with higher bin capacity and lower bin numbers for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign items to bins by calculating a score that is derived from the ratio of the rest capacity to the square root of the product of the bin number and the item size, while prioritizing bins with higher rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(np.arange(1,len(bins)+1)) * item)\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and the difference between the maximum capacity and the rest capacity of the bin, giving higher priority to bins with higher bin numbers, lower rest capacities, and larger differences between maximum and rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n bin_numbers = np.arange(len(bins)) # bin numbers from 0 to len(bins)-1\\n\\n # Calculate scores for each bin\\n scores = bin_numbers + (max_capacity - bins) - bins / max_capacity\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of the ratio of the rest capacity to the bin number and the logarithm of the bin capacity, prioritizing bins with higher rest capacity and lower bin numbers, while also considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacity_ratio = bins / bins.sum()\\n logarithmic_increase = np.log(bins)\\n \\n scores = rest_capacity_ratio * (1/bin_numbers) * logarithmic_increase\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with higher bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins\\n weighted_averages = (item + bins) / 2\\n\\n scores = bin_numbers * 100 + rest_capacities + weighted_averages\\n\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the square root of the rest capacity to the logarithm of the bin number, emphasizing both optimal utilization and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.log(1 + np.arange(1, len(bins) + 1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the sum of the rest capacity divided by the item size, the inverse of the bin number, and the logarithm of the ratio between the rest capacity and the item size, while excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.sum() - bins) / item + 1 / np.arange(1, len(bins) + 1) + np.log(bins / item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the sum of the rest capacity divided by the item size, considering all bins regardless of their capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins / item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"assign item to bin with maximum score based on rest capacity}). \\n\\nBased on this idea, the new algorithm assigns the item to the bin with the maximum score calculated by considering the rest capacity, the inverse of the bin number, and a weighted average of the rest capacity and the inverse of the bin number ({assign item to bin with maximum score based on rest capacity, bin number, and weighted average\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.amax(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] / max_capacity) + (1 / (i+1))\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of the rest capacity to the bin number, prioritizing bins with higher rest capacity and lower bin numbers for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for each bin by dividing the inverse of the rest capacity by the product of the bin number and the item size, and assign the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins * np.arange(1, len(bins)+1) * item)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin number, rest capacity, and a weighted average of the item size and the rest capacity, prioritizing bins with higher bin numbers, lower rest capacities, and lower weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n rest_capacity = bins\\n weighted_average = (item * (bins / np.sum(bins))) + ((1 - item) * (1 - (bins / np.sum(bins))))\\n scores = bin_numbers * rest_capacity * weighted_average\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin number, rest capacity, and a weighted average of the item size and the rest capacity, prioritizing bins with lower bin numbers, higher rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(len(bins))\\n rest_capacities = bins\\n weighted_avg = (item + rest_capacities) / rest_capacities\\n scores = -1 * (bin_nums + 1) * (rest_capacities ** 2) * weighted_avg\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign items to bins by calculating a score that is derived from the ratio of the rest capacity to the square root of the product of the bin number and the item size, while prioritizing bins with higher rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(np.arange(1,len(bins)+1)) * item)\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and the difference between the maximum capacity and the rest capacity of the bin, giving higher priority to bins with higher bin numbers, lower rest capacities, and larger differences between maximum and rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n bin_numbers = np.arange(len(bins)) # bin numbers from 0 to len(bins)-1\\n\\n # Calculate scores for each bin\\n scores = bin_numbers + (max_capacity - bins) - bins / max_capacity\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with lower bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_number_score = bins.size - np.arange(bins.size)\\n rest_capacity_score = bins.min() - bins\\n weighted_average_score = (item + bins) / 2\\n scores = bin_number_score + rest_capacity_score + weighted_average_score\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of the ratio of the rest capacity to the bin number and the logarithm of the bin capacity, prioritizing bins with higher rest capacity and lower bin numbers, while also considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacity_ratio = bins / bins.sum()\\n logarithmic_increase = np.log(bins)\\n \\n scores = rest_capacity_ratio * (1/bin_numbers) * logarithmic_increase\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"The new algorithm assigns the item to the bin with the highest score calculated based on the ratio of the weighted average of the bin number and the item size to the rest capacity, prioritizing bins with lower ratios for assignment.\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = (bins / item) * (1 / (bins - item + 1))\\n scores = np.argsort(ratios)\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with higher bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins\\n weighted_averages = (item + bins) / 2\\n\\n scores = bin_numbers * 100 + rest_capacities + weighted_averages\\n\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the square root of the rest capacity to the logarithm of the bin number, emphasizing both optimal utilization and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.log(1 + np.arange(1, len(bins) + 1))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score calculated by considering the sum of the rest capacity divided by the item size, the inverse of the bin number, and the logarithm of the ratio between the rest capacity and the item size, while excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.sum() - bins) / item + 1 / np.arange(1, len(bins) + 1) + np.log(bins / item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the sum of the rest capacity divided by the item size, considering all bins regardless of their capacity, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins / item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"assign item to bin with maximum score based on rest capacity}). \\n\\nBased on this idea, the new algorithm assigns the item to the bin with the maximum score calculated by considering the rest capacity, the inverse of the bin number, and a weighted average of the rest capacity and the inverse of the bin number ({assign item to bin with maximum score based on rest capacity, bin number, and weighted average\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.amax(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] / max_capacity) + (1 / (i+1))\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on the product of the inverse of the bin's rest capacity and the logarithm of the sum of the bin number and the item size, aiming to prioritize bins with lower rest capacity and higher bin numbers while considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log(item + np.arange(1,len(bins)+1))\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign items to bins by calculating a score that is derived from the ratio of the rest capacity to the square root of the product of the bin number and the item size, while prioritizing bins with higher rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(np.arange(1,len(bins)+1)) * item)\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and the difference between the maximum capacity and the rest capacity of the bin, giving higher priority to bins with higher bin numbers, lower rest capacities, and larger differences between maximum and rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n bin_numbers = np.arange(len(bins)) # bin numbers from 0 to len(bins)-1\\n\\n # Calculate scores for each bin\\n scores = bin_numbers + (max_capacity - bins) - bins / max_capacity\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with lower bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_number_score = bins.size - np.arange(bins.size)\\n rest_capacity_score = bins.min() - bins\\n weighted_average_score = (item + bins) / 2\\n scores = bin_number_score + rest_capacity_score + weighted_average_score\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on a combination of the ratio of the rest capacity to the bin number and the logarithm of the bin capacity, prioritizing bins with higher rest capacity and lower bin numbers, while also considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacity_ratio = bins / bins.sum()\\n logarithmic_increase = np.log(bins)\\n \\n scores = rest_capacity_ratio * (1/bin_numbers) * logarithmic_increase\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"The new algorithm assigns the item to the bin with the highest score calculated based on the ratio of the weighted average of the bin number and the item size to the rest capacity, prioritizing bins with lower ratios for assignment.\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = (bins / item) * (1 / (bins - item + 1))\\n scores = np.argsort(ratios)\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with higher bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(1, len(bins) + 1)\\n rest_capacities = bins\\n weighted_averages = (item + bins) / 2\\n\\n scores = bin_numbers * 100 + rest_capacities + weighted_averages\\n\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n continue\\n \\n rest_capacity = bin_capacity - item\\n \\n scores[i] = (rest_capacity / np.sqrt(i + 1)) * np.log(rest_capacity / item) * (i + 1) * np.sqrt(bin_capacity / item)\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity, the logarithm of the rest capacity, and the inverse of the bin number, prioritizing bins with higher rest capacity, lower bin numbers, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins - item\\n scores = rest_capacity * np.log(rest_capacity) * (1 / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with higher rest capacities, higher bin numbers, and lower item-size-to-rest-capacity ratios.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins)) + 1\\n ratios = item / (bins - item)\\n scores = bins + bin_numbers + ratios\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the square root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([])\\n \\n bin_numbers = np.arange(1, len(bins) + 1)\\n bin_capacity_ratios = bins / item\\n bin_rest_capacity_ratios = bins / (bins - item)\\n \\n scores = (bins - item) / np.sqrt(bin_numbers) + np.log(bin_rest_capacity_ratios) + bin_numbers * np.sqrt(bin_capacity_ratios)\\n scores[bins == bins.max()] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n \\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n rest_capacity = bins[i]\\n bin_number = i + 1\\n \\n score = (rest_capacity ** (1/3)) / (np.log(rest_capacity / item)) * (bin_number * (bins[i] / item) ** (1/3))\\n \\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin's rest capacity divided by the cube root of the bin number, the natural logarithm of the inverse of the ratio between the rest capacity and the item size, and the product of the bin number and the cube root of the ratio between the bin capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins.max() - item))**(1/3) * np.log(1 / (bins / item)) * (np.arange(len(bins)) + 1)**(1/3)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the rest capacity of the bin raised to the power of the bin number.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's rest capacity divided by the square root of the bin number, the natural logarithm of the ratio between the item size and the rest capacity, and the product of the bin number and the inverse of the item size, prioritizing bins with higher rest capacity, lower bin numbers, and lower item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item / bins) * (np.arange(1, len(bins)+1) / item)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the ratio between the bin's rest capacity and the item size, the inverse of the bin number, and the square root of the ratio between the rest capacity and the item size, excluding bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n continue\\n \\n score = ((bins[i] / item) ** 2) * (1 / (i + 1)) * np.sqrt(bins[i] / item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the inverse of the rest capacity and prioritize bins with lower inverse rest capacity for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the square root of the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(range(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign item to the bin with the maximum score based on the product of the inverse of the bin's rest capacity and the logarithm of the sum of the bin number and the item size, aiming to prioritize bins with lower rest capacity and higher bin numbers while considering the logarithmic increase in capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / bins) * np.log(item + np.arange(1,len(bins)+1))\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number multiplied by a constant factor.\\n2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + bins.sum() + np.arange(len(bins)) * 0.5)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the ratio of the bin's rest capacity to the square root of the bin number multiplied by a factor, and select the bin with the maximum score for assignment, aiming to prioritize bins with both lower rest capacity and lower bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * item\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and the difference between the maximum capacity and the rest capacity of the bin, giving higher priority to bins with higher bin numbers, lower rest capacities, and larger differences between maximum and rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n bin_numbers = np.arange(len(bins)) # bin numbers from 0 to len(bins)-1\\n\\n # Calculate scores for each bin\\n scores = bin_numbers + (max_capacity - bins) - bins / max_capacity\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns the item to the bin with the maximum score calculated by considering the bin number, rest capacity, and a weighted average of the item size and the rest capacity, giving higher priority to bins with lower bin numbers, lower rest capacities, and higher weighted averages.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_number_score = bins.size - np.arange(bins.size)\\n rest_capacity_score = bins.min() - bins\\n weighted_average_score = (item + bins) / 2\\n scores = bin_number_score + rest_capacity_score + weighted_average_score\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n1. For each bin, calculate a score based on the ratio of the item size to the sum of the rest capacity and the bin number.\\n2. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the rest capacity, the bin number, and a custom function that takes into account the item size, rest capacity, and bin number to prioritize the assignment of bins with lower rest capacities, lower bin numbers, and higher item-size-to-rest-capacity ratios.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_numbers = np.arange(len(bins))\\n ratios = item / bins\\n scores = bin_numbers + ratios\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its rest capacity and assign the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity != max_capacity:\\n scores[i] = (max_capacity - capacity) / capacity\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores for each bin based on a combination of rest capacity, item size, and bin index.}\\n\\nNew algorithm: {Calculate the scores for each bin by subtracting the product of the item size and the bin index from the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - (item * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the inverse of the item size by the product of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (item * bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the rest capacity by the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms all calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the maximum between the square root of the rest capacity and the ratio of item size to bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.sqrt(bins), item / np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the rest capacity squared by the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 2) / (item * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = item / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the inverse of the rest capacity, assigns the item to the bin with the minimum score, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n scores = np.where(bins == item, 0, scores)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item, set the rest capacities of bins that are not used to a negative value, and return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on some combination of rest capacity, item size, and bin index.\\nNew algorithm: Calculate the scores for each bin by taking the square root of the sum of the rest capacity and twice the bin index, and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = np.sqrt(bins + 2 * indices)\\n return scores\",\n \"objective\": 0.08492,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of its rest capacity, the size of the item, and a predefined weight, and then assigns the item to the bin with the maximum score at each step.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(len(bins), 0, -1) # decreasing weights for bins\\n\\n scores = bins - item + weights\\n \\n return scores\",\n \"objective\": 0.10102,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by dividing the difference between the rest capacity and the item size by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size divided by the rest capacity minus the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / (bins - item)) - np.log(np.arange(1, len(bins) + 1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the item size and the rest capacity divided by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / np.arange(1, len(bins)+1)\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the difference between the maximum capacity and the rest capacity of a bin to the sum of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n rest_capacity[rest_capacity < 0] = max_capacity\\n scores = (max_capacity - rest_capacity) / (item + np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size divided by the rest capacity minus the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / (bins - item)) - np.log(np.arange(1, len(bins) + 1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the item size and the rest capacity divided by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / np.arange(1, len(bins)+1)\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the difference between the maximum capacity and the rest capacity of a bin to the sum of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n rest_capacity[rest_capacity < 0] = max_capacity\\n scores = (max_capacity - rest_capacity) / (item + np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on a combination of item size and the rest capacity of bins to determine the best bin for item assignment.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the logarithm of the rest capacity and the square of the item size, divided by the bin index multiplied by a constant delta.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n delta = 0.5\\n bin_indices = np.arange(1, len(bins) + 1)\\n scores = (np.log(bins) - item**2) / (bin_indices * delta)\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity multiplied by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the item size and the rest capacity divided by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / np.arange(1, len(bins)+1)\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the difference between the maximum capacity and the rest capacity of a bin to the sum of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n rest_capacity[rest_capacity < 0] = max_capacity\\n scores = (max_capacity - rest_capacity) / (item + np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on a combination of item size and the rest capacity of bins to determine the best bin for item assignment.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the logarithm of the rest capacity and the square of the item size, divided by the bin index multiplied by a constant delta.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n delta = 0.5\\n bin_indices = np.arange(1, len(bins) + 1)\\n scores = (np.log(bins) - item**2) / (bin_indices * delta)\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity multiplied by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the item size and the rest capacity divided by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / np.arange(1, len(bins)+1)\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the difference between the maximum capacity and the rest capacity of a bin to the sum of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = bins - item\\n rest_capacity[rest_capacity < 0] = max_capacity\\n scores = (max_capacity - rest_capacity) / (item + np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"C\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = (bins != np.max(bins))\\n scores[mask] = item / (np.maximum(bins[mask] - item, np.ones_like(bins[mask])))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the rest capacity to the square root of the bin index, multiplied by the logarithm of the item size, then return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) * np.log(item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identify the common backbone idea: Assign scores to bins based on a combination or manipulation of the item size, rest capacity, and bin index.\\n\\nBased on the backbone idea, my new algorithm is: Assign scores to bins based on the difference between the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 0.5\\n scores = (item ** 2 / bins) - (np.arange(len(bins)) * gamma)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its rest capacity and assign the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity != max_capacity:\\n scores[i] = (max_capacity - capacity) / capacity\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the inverse of the bin index by the rest capacity multiplied by a constant factor, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (1 / (i + 1)) / ((max_capacity - capacity) * 0.5)\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by subtracting the product of the bin index and the rest capacity from the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\n\\ndef score(item, bins):\\n scores = item - np.arange(len(bins)) * bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the square root of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (np.sqrt(item) + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the inverse of the item size by the product of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (item * bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.\\n\\nNew algorithm: Assign scores to bins based on the square of the inverted rest capacity divided by the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity_ratio = bins.astype(float) / item\\n scores = np.square(1 / capacity_ratio) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the sum of the rest capacity and the square of the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins + item) ** 2) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity divided by the square of the bin index and the product of the item size and the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = np.minimum(rest_capacity / np.square(indices), item * rest_capacity)\\n \\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the rest capacity by the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms all calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the maximum between the square root of the rest capacity and the ratio of item size to bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.sqrt(bins), item / np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores for each bin based on their rest capacities squared divided by the item size multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins**2) / (item * np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = item / (bins[mask] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the inverse of the rest capacity, assigns the item to the bin with the minimum score, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / bins\\n scores = np.where(bins == item, 0, scores)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin by multiplying the rest capacity with the inverse of the bin index and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (1 / np.arange(1, len(bins) + 1))\\n scores[bins == item] = 0\\n return scores\",\n \"objective\": 0.05322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item, set the rest capacities of bins that are not used to a negative value, and return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n scores[bins == item] = -1\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by considering the logarithm of the item size, weighted by the bin index and the difference between the item size and the bin index, divided by the rest capacity and the product of the difference mentioned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * (bins / item) * (np.log(item) / (bins - item)) * (np.arange(len(bins)) / item)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm divides the item size by the sum of the rest capacity and the logarithm (base 2) of the bin index to determine the scores for assigning items to bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log2(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identify the common backbone idea: Assign scores to bins based on a combination or manipulation of the item size, rest capacity, and bin index.\\n\\nBased on the backbone idea, my new algorithm is: Assign scores to bins based on the difference between the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 0.5\\n scores = (item ** 2 / bins) - (np.arange(len(bins)) * gamma)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by considering the logarithm of the item size, weighted by the bin index and the difference between the item size and the bin index, divided by the rest capacity and the product of the difference mentioned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * (bins / item) * (np.log(item) / (bins - item)) * (np.arange(len(bins)) / item)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm divides the item size by the sum of the rest capacity and the logarithm (base 2) of the bin index to determine the scores for assigning items to bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log2(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identify the common backbone idea: Assign scores to bins based on a combination or manipulation of the item size, rest capacity, and bin index.\\n\\nBased on the backbone idea, my new algorithm is: Assign scores to bins based on the difference between the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 0.5\\n scores = (item ** 2 / bins) - (np.arange(len(bins)) * gamma)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the square of the item size and the inverse of the rest capacity, subtracting the bin index from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) * (1/bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the ratio between the squared difference of rest capacity and a constant alpha, and the absolute difference of the item size and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n beta = 2.0\\n gamma = 0.5\\n \\n squared_diff = np.square(bins - item) - alpha\\n abs_diff = np.abs(bins - item) - beta\\n bin_index = np.arange(len(bins)) + 1\\n \\n scores = (squared_diff / abs_diff) / np.power(bin_index, gamma)\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the sum of the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 10\\n scores = (item ** 2) / (bins - item) + gamma * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by considering the logarithm of the item size, weighted by the bin index and the difference between the item size and the bin index, divided by the rest capacity and the product of the difference mentioned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * (bins / item) * (np.log(item) / (bins - item)) * (np.arange(len(bins)) / item)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the item size divided by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm divides the item size by the sum of the logarithm (base 2) of the bin index and the rest capacity divided by the maximum capacity, multiplied by the square root of the bin index plus one, to determine the scores for assigning items to bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n scores = item / (np.log2(bin_indices + 1) + rest_capacity / max_capacity) * np.sqrt(bin_indices + 1)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm divides the item size by the sum of the rest capacity and the logarithm (base 2) of the bin index to determine the scores for assigning items to bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log2(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identify the common backbone idea: Assign scores to bins based on a combination or manipulation of the item size, rest capacity, and bin index.\\n\\nBased on the backbone idea, my new algorithm is: Assign scores to bins based on the difference between the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 0.5\\n scores = (item ** 2 / bins) - (np.arange(len(bins)) * gamma)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the difference between the item size and the bin index, multiplied by the logarithm of the rest capacity, plus the sum of the item size and the bin index, divided by the square of the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item - bin_index) * np.log(rest_capacity) + (item + bin_index) / (rest_capacity ** 2)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score based on a combination of the item size, bin index, and rest capacity.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size multiplied by the bin index, divided by the sum of the rest capacity and the square of the difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * np.arange(len(bins)) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02354,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the ratio between the squared difference of rest capacity and a constant alpha, and the absolute difference of the item size and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n beta = 2.0\\n gamma = 0.5\\n \\n squared_diff = np.square(bins - item) - alpha\\n abs_diff = np.abs(bins - item) - beta\\n bin_index = np.arange(len(bins)) + 1\\n \\n scores = (squared_diff / abs_diff) / np.power(bin_index, gamma)\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the sum of the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 10\\n scores = (item ** 2) / (bins - item) + gamma * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by considering the logarithm of the item size, weighted by the bin index and the difference between the item size and the bin index, divided by the rest capacity and the product of the difference mentioned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * (bins / item) * (np.log(item) / (bins - item)) * (np.arange(len(bins)) / item)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Divide the square of the item size by the product of the rest capacity and the bin index to the power of the inverse of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins.copy()\\n rest_capacity[rest_capacity == item] = 0\\n \\n bin_index = np.arange(len(bins)) + 1\\n \\n scores = (item**2) / (rest_capacity * bin_index**(1/item))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the difference between the item size and the bin index, multiplied by the logarithm of the rest capacity, plus the sum of the item size and the bin index, divided by the square of the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item - bin_index) * np.log(rest_capacity) + (item + bin_index) / (rest_capacity ** 2)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score based on a combination of the item size, bin index, and rest capacity.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size multiplied by the bin index, divided by the sum of the rest capacity and the square of the difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * np.arange(len(bins)) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02354,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the product of the cube root of the item size multiplied by the bin index, divided by the square root of the rest capacity plus the absolute value of the difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(np.cbrt(item) * np.arange(len(bins))) / (np.sqrt(bins) + np.abs(item - np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the ratio between the squared difference of rest capacity and a constant alpha, and the absolute difference of the item size and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n beta = 2.0\\n gamma = 0.5\\n \\n squared_diff = np.square(bins - item) - alpha\\n abs_diff = np.abs(bins - item) - beta\\n bin_index = np.arange(len(bins)) + 1\\n \\n scores = (squared_diff / abs_diff) / np.power(bin_index, gamma)\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n scores = (item / (bins - item)) - bin_indices\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the sum of the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 10\\n scores = (item ** 2) / (bins - item) + gamma * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by considering the logarithm of the item size, weighted by the bin index and the difference between the item size and the bin index, divided by the rest capacity and the product of the difference mentioned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * (bins / item) * (np.log(item) / (bins - item)) * (np.arange(len(bins)) / item)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Divide the square of the item size by the product of the rest capacity and the bin index to the power of the inverse of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins.copy()\\n rest_capacity[rest_capacity == item] = 0\\n \\n bin_index = np.arange(len(bins)) + 1\\n \\n scores = (item**2) / (rest_capacity * bin_index**(1/item))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the difference between the item size and the bin index, multiplied by the logarithm of the rest capacity, plus the sum of the item size and the bin index, divided by the square of the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item - bin_index) * np.log(rest_capacity) + (item + bin_index) / (rest_capacity ** 2)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the cosine of the bin index divided by the sum of the logarithm of the item size and the rest capacity, multiplied by the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n bin_capacity = bins - item\\n scores = np.cos(bin_index / (np.log(item) + np.log(bin_capacity))) * np.sqrt(bin_index)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score based on a combination of the item size, bin index, and rest capacity.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size multiplied by the bin index, divided by the sum of the rest capacity and the square of the difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * np.arange(len(bins)) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02354,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the logarithm of the product of the cube root of the item size multiplied by the bin index, divided by the square root of the rest capacity plus the absolute value of the difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(np.cbrt(item) * np.arange(len(bins))) / (np.sqrt(bins) + np.abs(item - np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Assign scores to bins based on the ratio between the squared difference of rest capacity and a constant alpha, and the absolute difference of the item size and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n beta = 2.0\\n gamma = 0.5\\n \\n squared_diff = np.square(bins - item) - alpha\\n abs_diff = np.abs(bins - item) - beta\\n bin_index = np.arange(len(bins)) + 1\\n \\n scores = (squared_diff / abs_diff) / np.power(bin_index, gamma)\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity subtracted from the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins > item)\\n scores[bins == bins.max()] = np.NINF\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the inverse of the rest capacity and a constant beta (where beta can be adjusted to control the importance of rest capacity in scoring), divided by the bin index subtracted by a constant delta (where delta can be adjusted to alter the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5 # Adjust the importance of rest capacity in scoring\\n delta = 0.1 # Adjust the influence of bin index in scoring\\n\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n\\n scores = (beta / rest_capacity) / (indices - delta)\\n scores[rest_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the sum of the square of the item size divided by the rest capacity, and the bin index multiplied by a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n gamma = 10\\n scores = (item ** 2) / (bins - item) + gamma * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by considering the logarithm of the item size, weighted by the bin index and the difference between the item size and the bin index, divided by the rest capacity and the product of the difference mentioned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * (bins / item) * (np.log(item) / (bins - item)) * (np.arange(len(bins)) / item)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size divided by the rest capacity raised to the power of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to bins based on some combination or manipulation of the item size, rest capacity, and bin index.}\\n\\n{New algorithm: Divide the square of the item size by the product of the rest capacity and the bin index to the power of the inverse of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins.copy()\\n rest_capacity[rest_capacity == item] = 0\\n \\n bin_index = np.arange(len(bins)) + 1\\n \\n scores = (item**2) / (rest_capacity * bin_index**(1/item))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the cube root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of item size by the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, (bins + np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its rest capacity and assign the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity != max_capacity:\\n scores[i] = (max_capacity - capacity) / capacity\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reverse algorithm: The score function will calculate the scores for each bin by subtracting the rest capacity of the bin from the product of the bin index and the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the square root of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (np.sqrt(item) + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the square root of the item size and the ratio of the bin's rest capacity to the bin index, subtracting the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = np.sqrt(item) * (capacity / (i+1)) - item\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the inverse of the item size by the product of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (item * bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the scores for each bin by dividing the inverse of the bin index by the squared rest capacity multiplied by a different constant factor, returning the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.arange(1, len(bins) + 1)) / (bins ** 2)\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n unused_bins = np.where(bins == max_capacity)[0]\\n\\n if len(unused_bins) == len(bins):\\n return scores\\n\\n scores[unused_bins] = -1\\n\\n non_empty_bins = np.where(bins < max_capacity)[0]\\n\\n scores[non_empty_bins] = (max_capacity - bins[non_empty_bins]) / item\\n\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the sum of the rest capacity and the square of the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins + item) ** 2) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity divided by the square of the bin index and the product of the item size and the rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = np.minimum(rest_capacity / np.square(indices), item * rest_capacity)\\n \\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the rest capacity by the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * np.arange(1, len(bins)+1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, (bins + np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its rest capacity and assign the item to the bin with the highest score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity != max_capacity:\\n scores[i] = (max_capacity - capacity) / capacity\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reverse algorithm: The score function will calculate the scores for each bin by subtracting the rest capacity of the bin from the product of the bin index and the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the square root of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (np.sqrt(item) + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the square root of the item size and the ratio of the bin's rest capacity to the bin index, subtracting the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = np.sqrt(item) * (capacity / (i+1)) - item\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the inverse of the item size by the product of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (item * bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the scores for each bin by dividing the inverse of the bin index by the squared rest capacity multiplied by a different constant factor, returning the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.arange(1, len(bins) + 1)) / (bins ** 2)\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"N\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n unused_bins = np.where(bins == max_capacity)[0]\\n\\n if len(unused_bins) == len(bins):\\n return scores\\n\\n scores[unused_bins] = -1\\n\\n non_empty_bins = np.where(bins < max_capacity)[0]\\n\\n scores[non_empty_bins] = (max_capacity - bins[non_empty_bins]) / item\\n\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the sum of the rest capacity and the square of the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins + item) ** 2) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, (bins + np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the rest capacity of each bin, dividing it by the bin index plus one, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / (np.arange(len(bins)) + 1) \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reverse algorithm: The score function will calculate the scores for each bin by subtracting the rest capacity of the bin from the product of the bin index and the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin by taking the sum of the inverse of the rest capacity and the square root of the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.sqrt(item * np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the square root of the item size and the ratio of the bin's rest capacity to the bin index, subtracting the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, capacity in enumerate(bins):\\n if capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = np.sqrt(item) * (capacity / (i+1)) - item\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by dividing the inverse of the item size by the product of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (item * bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the scores for each bin by dividing the inverse of the bin index by the squared rest capacity multiplied by a different constant factor, returning the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / np.arange(1, len(bins) + 1)) / (bins ** 2)\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, subtracting the square root of the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n scores = (item * np.abs(bins - beta)) / (np.power(np.arange(1,len(bins)+1), gamma) - np.sqrt(np.arange(1,len(bins)+1)) * (1/item))\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the sum of the rest capacity and the square of the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins + item) ** 2) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the square of the bin index, and assign items to the bin with the maximum score in each step to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n bin_indices = np.arange(len(bins)) + 1\\n scores = np.abs(bins - item - beta) / (bin_indices ** 2)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(item, (bins + np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the rest capacity of each bin, dividing it by the bin index plus one, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / (np.arange(len(bins)) + 1) \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reverse algorithm: The score function will calculate the scores for each bin by subtracting the rest capacity of the bin from the product of the bin index and the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin by taking the sum of the inverse of the rest capacity and the square root of the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.sqrt(item * np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin by taking the difference between the rest capacity and the product of the item size and the bin index, subtracting the natural logarithm of the bin index, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1) # Generate bin indices\\n scores = bins - item * bin_indices - np.log(bin_indices) # Calculate scores\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the square of the bin index, and assign items to the bin with the maximum score in each step to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n bin_indices = np.arange(len(bins)) + 1\\n scores = np.abs(bins - item - beta) / (bin_indices ** 2)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores based on the logarithm of the item size divided by the sum of the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / (bins + np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the rest capacity of each bin, dividing it by the bin index plus one, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / (np.arange(len(bins)) + 1) \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reverse algorithm: The score function will calculate the scores for each bin by subtracting the rest capacity of the bin from the product of the bin index and the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin by taking the sum of the inverse of the rest capacity and the square root of the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) + np.sqrt(item * np.arange(1,len(bins)+1))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin by taking the difference between the rest capacity and the product of the item size and the bin index, subtracting the natural logarithm of the bin index, and returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins) + 1) # Generate bin indices\\n scores = bins - item * bin_indices - np.log(bin_indices) # Calculate scores\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size divided by the rest capacity minus the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / (bins - item)) - np.log(np.arange(1, len(bins) + 1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the square of the bin index, and assign items to the bin with the maximum score in each step to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n bin_indices = np.arange(len(bins)) + 1\\n scores = np.abs(bins - item - beta) / (bin_indices ** 2)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the sum of the item size and the rest capacity of each bin, dividing it by the bin index plus one, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / (np.arange(len(bins)) + 1) \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reverse algorithm: The score function will calculate the scores for each bin by subtracting the rest capacity of the bin from the product of the bin index and the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Assign scores to bins based on the ratio of the bin index multiplied by the inverse of the item size to the rest capacity, subtracting the square of the item size from the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.where(bins > item)[0]\\n scores = np.zeros_like(bins)\\n if len(bin_indices) == 0:\\n return scores\\n \\n bin_sizes = bins[bin_indices]\\n ratios = (bin_indices * (1/item)) / bin_sizes\\n scores[bin_indices] = ratios - np.square(item)\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size multiplied by the bin index, divided by the sum of the rest capacity and the squared difference between the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item * np.arange(len(bins))) / (bins + (item - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the absolute difference between the rest capacity and a constant beta, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 10\\n gamma = 2\\n \\n rest_capacity = bins - item\\n scores = np.abs(rest_capacity - beta) / np.power(np.arange(1, len(bins) + 1), gamma)\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the square root of the item size divided by the rest capacity minus the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / (bins - item)) - np.log(np.arange(1, len(bins) + 1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha (where alpha can be adjusted to fine-tune the importance of rest capacity in scoring), divided by the bin index raised to the power of a constant gamma (where gamma can be adjusted to control the influence of bin index in scoring), returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n gamma = 0.2\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins)+1), gamma)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the product of the item size and the inverted rest capacity, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins+1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on item size and rest capacity of bins to assign item to bin with maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the logarithm of the item size divided by the rest capacity plus the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the division of the item size by the sum of the rest capacity and the square root of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the item size by the sum of the rest capacity and the logarithm of the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.log(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores based on the item size and the rest capacity of bins to assign an item to the bin with the maximum score.}\\n\\n{New algorithm: Assign scores to bins based on the difference between the item size and the square root of the rest capacity, multiplied by the bin index raised to the power of two, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and square root of the rest capacity\\n diff = item - np.sqrt(bins)\\n \\n # Calculate the scores based on the difference and the bin index raised to the power of two\\n scores = diff * np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins)+1)**(-0.5)\\n scores = bins * weights\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the product of the item size and the squared difference between the rest capacity and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (bins - np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the ratio of the item size to the rest capacity, subtracting the bin index multiplied by the inverse of the item size from the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (np.arange(len(bins)) * (1/item))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to bins based on the item size divided by the rest capacity plus the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the difference between the maximum capacity and the rest capacity of a bin by the sum of the item size and the bin index to calculate the score for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm: Calculate scores for bins by subtracting the logarithm of both the rest capacity and item size from the product of the bin index and the square root of the item size, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n sqrt_item_size = np.sqrt(item)\\n scores = indices * sqrt_item_size - np.log(bins) - np.log(item)\\n scores[bins == item] = np.inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the item size and the rest capacity divided by the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item + bins) / np.arange(1, len(bins)+1)\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the rest capacity and other parameters to determine the optimal bin for item assignment.}\\n\\n{New algorithm: The new algorithm calculates the score for each bin by taking the sum of the rest capacity and the product of the item size and the bin index, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign scores to bins based on the square root of the rest capacity multiplied by a constant alpha, divided by the bin index raised to the power of a constant gamma, returning the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 1.5\\n gamma = 0.75\\n scores = np.sqrt(bins) * alpha / np.power(np.arange(1, len(bins) + 1), gamma)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reverse algorithm: The score function will calculate the scores for each bin by subtracting the rest capacity of the bin from the product of the bin index and the item size and return the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the square of the item size by the rest capacity, giving priority to bins with lower rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(item) / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the score function to prioritize assigning items to bins that are closer to their maximum capacity, thus minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=int)\\n sorted_indices = np.argsort(bins)\\n \\n for i in range(len(bins)):\\n bin_index = sorted_indices[i]\\n if bins[bin_index] == item:\\n scores[bin_index] = -1 # If bin is exactly equal to item size, do not use it\\n else:\\n scores[bin_index] = item - bins[bin_index] # Calculate score based on how close the bin is to its maximum capacity\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the remaining/rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin by dividing the item size by the sum of the rest capacity and its index, favoring bins with higher indices and lower rest capacity, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)) + 1)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.sqrt(1 / np.arange(1, len(bins) + 1))\\n scores = (bins * weights) + (item * weights)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by taking the square root of the item size divided by the product of the rest capacity and its index, promoting bins with lower rest capacity and lower index for assignment, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / (bins * np.arange(1, len(bins)+1)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores for bins based on their rest capacity and prioritize bins with higher rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin number multiplied by the rest capacity, returning an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.arange(len(bins)) + 1) * bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of the bin's remaining capacity to the item size, incorporating a logarithmic function of the bin capacity and item size, to assign the item to the bin with the highest score in each step.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != bins.max()\\n scores[mask] = np.log(bins[mask] / item)\\n return scores\",\n \"objective\": 0.05614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin by multiplying the remaining/rest capacity by the bin index, favoring lower capacity bins with higher indices for assignment, while penalizing bins with rest capacity equal to the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins != max_capacity) * ((max_capacity - bins) * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.05886,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to -1 if the available capacity is less than or equal to half of the item size, otherwise set the score to the available capacity minus the item size. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -2 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity <= item/2, -1, available_capacity - item)\\n scores = np.where(bins == np.max(bins), -2, scores)\\n return scores\",\n \"objective\": 0.06077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by taking the difference between the item size and the rest capacity squared, divided by the index squared, promoting bins with lower rest capacity and lower index for assignment, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the index squared for each bin\\n index_squared = np.arange(1, len(bins)+1)**2\\n \\n # Calculate the difference between item size and rest capacity squared for each bin\\n diff_squared = (item - bins)**2\\n \\n # Calculate the scores for each bin\\n scores = diff_squared / index_squared\\n \\n # Penalize bins with rest capacity equal to the maximum capacity\\n scores[bins == np.max(bins)] = -1\\n \\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by dividing the remaining capacity of each bin by the size of the current item, subtracting 1 if the remaining capacity is equal to the maximum capacity, and setting the score to 0 if the remaining capacity is less than or equal to four times the item size, then it returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity / item\\n scores[remaining_capacity == max_capacity] -= 1\\n scores[remaining_capacity <= 4 * item] = 0\\n return scores\",\n \"objective\": 0.06983,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, lower index, and a lower value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 0.5\\n bin_index = np.arange(1, len(bins) + 1)\\n rest_capacity_index = (bins - item) ** bin_index\\n scores = (item * bin_index) / (rest_capacity_index * k)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin plus the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = float('-inf')\\n else:\\n scores[i] = item / (rest_capacity - item) + np.sqrt(i)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n capacities = bins - item\\n scores = (np.log(item) * bin_indices) / (capacities ** np.sqrt(bin_indices))\\n scores[capacities == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin index squared and the inverse of the remaining capacity, aiming to prioritize bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = indices ** 2 / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns scores to each bin based on the logarithm of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the cube root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * np.arange(len(bins))\\n scores /= bins**(1/3)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the exponential function of the item size divided by the sum of the rest capacity and the logarithm of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(item / (bins + np.log(range(1, len(bins)+1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the logarithmic function of the item size divided by the sum of the rest capacity and the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n size_ratio = np.log(item) / np.log(2)\\n rest_ratio = (bins / np.sum(bins)) ** 2\\n index_ratio = (np.arange(1, len(bins) + 1) / len(bins)) ** 3\\n \\n scores = size_ratio / (rest_ratio + index_ratio)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the product of the item size divided by the difference between the rest capacity and the logarithm of the bin index, aiming to prioritize bins with smaller rest capacity and higher index while maintaining a balance between item size and bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins)) + 1\\n log_indices = np.log(indices)\\n scores = (item / (bins - log_indices)).astype(np.float64)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n scores = (np.log(item) * index) / (remainder_capacity ** index)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the product of the item size and the bin index, divided by the square root of the remainder capacity raised to the power of the exponential function of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, lower rest capacity, and a higher rate of decrease in capacity with increasing index.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n scores = (item * index) / (np.sqrt(remainder_capacity) ** index)\\n max_score = np.max(scores)\\n scores[remainder_capacity == np.max(bins)] = -np.inf\\n scores[np.isnan(scores)] = -np.inf\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin plus the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = float('-inf')\\n else:\\n scores[i] = item / (rest_capacity - item) + np.sqrt(i)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function assigns scores to each bin by dividing the square of the bin index by the difference between the item size and the remainder capacity, aiming to prioritize bins with higher index values and a larger difference between item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n \\n scores = bin_index / remainder_capacity**2\\n scores[remainder_capacity == item] = 0\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n capacities = bins - item\\n scores = (np.log(item) * bin_indices) / (capacities ** np.sqrt(bin_indices))\\n scores[capacities == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse of the bin index plus the product of the inverse of the remaining capacity and the square root of the bin index, aiming to prioritize both bins with lower indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(bins.size) + 1\\n remaining_capacities = bins - item\\n remaining_capacities[remaining_capacities < 0] = 0\\n scores = 1 / bin_indices + (1 / remaining_capacities) * np.sqrt(bin_indices)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse of the bin index plus the product of the inverse of the remaining capacity and the logarithm of the bin index, aiming to prioritize both bins with lower indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n inverse_bin_indices = 1 / (bin_indices + 1)\\n inverse_remaining_capacities = 1 / remaining_capacities\\n\\n scores = inverse_bin_indices + inverse_remaining_capacities * np.log(bin_indices + 1)\\n scores[remaining_capacities == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin index squared and the inverse of the remaining capacity, aiming to prioritize bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = indices ** 2 / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the product of the item size and the bin index, divided by the square root of the remainder capacity raised to the power of the exponential function of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, lower rest capacity, and a higher rate of decrease in capacity with increasing index.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n scores = (item * index) / (np.sqrt(remainder_capacity) ** index)\\n max_score = np.max(scores)\\n scores[remainder_capacity == np.max(bins)] = -np.inf\\n scores[np.isnan(scores)] = -np.inf\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin plus the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = float('-inf')\\n else:\\n scores[i] = item / (rest_capacity - item) + np.sqrt(i)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function assigns scores to each bin by dividing the square of the bin index by the difference between the item size and the remainder capacity, aiming to prioritize bins with higher index values and a larger difference between item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n \\n scores = bin_index / remainder_capacity**2\\n scores[remainder_capacity == item] = 0\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n capacities = bins - item\\n scores = (np.log(item) * bin_indices) / (capacities ** np.sqrt(bin_indices))\\n scores[capacities == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse of the bin index plus the product of the inverse of the remaining capacity and the square root of the bin index, aiming to prioritize both bins with lower indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(bins.size) + 1\\n remaining_capacities = bins - item\\n remaining_capacities[remaining_capacities < 0] = 0\\n scores = 1 / bin_indices + (1 / remaining_capacities) * np.sqrt(bin_indices)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse of the bin index plus the product of the inverse of the remaining capacity and the logarithm of the bin index, aiming to prioritize both bins with lower indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n inverse_bin_indices = 1 / (bin_indices + 1)\\n inverse_remaining_capacities = 1 / remaining_capacities\\n\\n scores = inverse_bin_indices + inverse_remaining_capacities * np.log(bin_indices + 1)\\n scores[remaining_capacities == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index and the exponential function of the difference between the item size and the remaining capacity, aiming to balance the index of the bin and the difference in size and capacity while favoring bins with higher indices and smaller differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_scores = np.sqrt(np.arange(1, len(bins)+1)) # score based on bin index\\n size_scores = np.exp(item - bins) # score based on difference in size and capacity\\n scores = index_scores + size_scores # combine the scores\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square of the item size divided by the index of the bin plus the remainder capacity, in order to favor smaller items and bins with higher index and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n capacity = bins % item\\n scores = (item**2) / (index + capacity)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function assigns scores to each bin by dividing the square of the bin index by the difference between the item size and the remainder capacity, aiming to prioritize bins with higher index values and a larger difference between item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n \\n scores = bin_index / remainder_capacity**2\\n scores[remainder_capacity == item] = 0\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin index and the item size, divided by the exponentiation of the remainder capacity raised to the power of the square root of the bin index, aiming to balance the bin index, the item size, and the relative decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remainder_capacity = bins - item\\n scores = (bin_indices * item) / np.power(remainder_capacity, np.sqrt(bin_indices))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index and the exponential function of the difference between the item size and the remaining capacity, aiming to balance the index of the bin and the difference in size and capacity while favoring bins with higher indices and smaller differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_scores = np.sqrt(np.arange(1, len(bins)+1)) # score based on bin index\\n size_scores = np.exp(item - bins) # score based on difference in size and capacity\\n scores = index_scores + size_scores # combine the scores\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square of the item size divided by the index of the bin plus the remainder capacity, in order to favor smaller items and bins with higher index and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n capacity = bins % item\\n scores = (item**2) / (index + capacity)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function assigns scores to each bin by dividing the square of the bin index by the difference between the item size and the remainder capacity, aiming to prioritize bins with higher index values and a larger difference between item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n \\n scores = bin_index / remainder_capacity**2\\n scores[remainder_capacity == item] = 0\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the bin index multiplied by a constant value and the square root of the bin's maximum capacity, aiming to prioritize bins with lower remaining capacity, lower index, and larger maximum capacity while addressing the size of the item and providing a balanced scoring mechanism.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1) * np.sqrt(bins)\\n scores[bins == np.amax(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index and the exponential function of the difference between the item size and the remaining capacity, aiming to balance the index of the bin and the difference in size and capacity while favoring bins with higher indices and smaller differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_scores = np.sqrt(np.arange(1, len(bins)+1)) # score based on bin index\\n size_scores = np.exp(item - bins) # score based on difference in size and capacity\\n scores = index_scores + size_scores # combine the scores\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square of the item size divided by the index of the bin plus the remainder capacity, in order to favor smaller items and bins with higher index and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n capacity = bins % item\\n scores = (item**2) / (index + capacity)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function assigns scores to each bin by dividing the square of the bin index by the difference between the item size and the remainder capacity, aiming to prioritize bins with higher index values and a larger difference between item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remainder_capacity = bins - item\\n \\n scores = bin_index / remainder_capacity**2\\n scores[remainder_capacity == item] = 0\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the bin index multiplied by a constant value and the square root of the bin's maximum capacity, aiming to prioritize bins with lower remaining capacity, lower index, and larger maximum capacity while addressing the size of the item and providing a balanced scoring mechanism.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1) * np.sqrt(bins)\\n scores[bins == np.amax(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index and the exponential function of the difference between the item size and the remaining capacity, aiming to balance the index of the bin and the difference in size and capacity while favoring bins with higher indices and smaller differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_scores = np.sqrt(np.arange(1, len(bins)+1)) # score based on bin index\\n size_scores = np.exp(item - bins) # score based on difference in size and capacity\\n scores = index_scores + size_scores # combine the scores\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function assigns scores to each bin based on the difference between the item size and the rest capacity multiplied by the bin index divided by the sum of the bin index and the square root of the remainder capacity, aiming to prioritize bins with a larger difference between item size and remaining capacity, as well as bins with higher indices and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) * np.arange(1, len(bins)+1) / (np.arange(1, len(bins)+1) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, divided by the bin index squared, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) / (np.arange(len(bins)) ** 2)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of the item size to the rest capacity raised to the power of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while addressing the utilization of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** np.arange(1, len(bins)+1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the bin index multiplied by a constant value and the square root of the bin's maximum capacity, aiming to prioritize bins with lower remaining capacity, lower index, and larger maximum capacity while addressing the size of the item and providing a balanced scoring mechanism.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1) * np.sqrt(bins)\\n scores[bins == np.amax(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index and the logarithmic value of the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = bin_index * np.log(remaining_capacity) ** bin_index\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index and the exponential function of the difference between the item size and the remaining capacity, aiming to balance the index of the bin and the difference in size and capacity while favoring bins with higher indices and smaller differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_scores = np.sqrt(np.arange(1, len(bins)+1)) # score based on bin index\\n size_scores = np.exp(item - bins) # score based on difference in size and capacity\\n scores = index_scores + size_scores # combine the scores\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function assigns scores to each bin based on the difference between the item size and the rest capacity multiplied by the bin index divided by the sum of the bin index and the square root of the remainder capacity, aiming to prioritize bins with a larger difference between item size and remaining capacity, as well as bins with higher indices and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) * np.arange(1, len(bins)+1) / (np.arange(1, len(bins)+1) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, divided by the bin index squared, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) / (np.arange(len(bins)) ** 2)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index and the logarithmic value of the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = bin_index * np.log(remaining_capacity) ** bin_index\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index, the logarithm of the remaining capacity raised to the power of 2, and the inverse of the item size, aiming to prioritize both bins with higher indices, larger remaining capacities, and smaller item sizes for an optimal bin assignment to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = np.log10(bins - item) ** 2\\n item_size_inverse = 1 / item\\n\\n scores = np.sqrt(bin_indices) + remaining_capacity + item_size_inverse\\n scores[bins == np.max(bins)] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index and the exponential function of the difference between the item size and the remaining capacity, aiming to balance the index of the bin and the difference in size and capacity while favoring bins with higher indices and smaller differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_scores = np.sqrt(np.arange(1, len(bins)+1)) # score based on bin index\\n size_scores = np.exp(item - bins) # score based on difference in size and capacity\\n scores = index_scores + size_scores # combine the scores\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function assigns scores to each bin based on the difference between the item size and the rest capacity multiplied by the bin index divided by the sum of the bin index and the square root of the remainder capacity, aiming to prioritize bins with a larger difference between item size and remaining capacity, as well as bins with higher indices and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) * np.arange(1, len(bins)+1) / (np.arange(1, len(bins)+1) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n inverse_exponential = np.exp(-bin_indexes)\\n remaining_capacity_power = remaining_capacity ** bin_indexes\\n \\n ratio = item / remaining_capacity\\n \\n scores = inverse_exponential * remaining_capacity_power * ratio\\n\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index and the logarithmic value of the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = bin_index * np.log(remaining_capacity) ** bin_index\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index, the logarithm of the remaining capacity raised to the power of 2, and the inverse of the item size, aiming to prioritize both bins with higher indices, larger remaining capacities, and smaller item sizes for an optimal bin assignment to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = np.log10(bins - item) ** 2\\n item_size_inverse = 1 / item\\n\\n scores = np.sqrt(bin_indices) + remaining_capacity + item_size_inverse\\n scores[bins == np.max(bins)] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index and the exponential function of the difference between the item size and the remaining capacity, aiming to balance the index of the bin and the difference in size and capacity while favoring bins with higher indices and smaller differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_scores = np.sqrt(np.arange(1, len(bins)+1)) # score based on bin index\\n size_scores = np.exp(item - bins) # score based on difference in size and capacity\\n scores = index_scores + size_scores # combine the scores\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function assigns scores to each bin based on the difference between the item size and the rest capacity multiplied by the bin index divided by the sum of the bin index and the square root of the remainder capacity, aiming to prioritize bins with a larger difference between item size and remaining capacity, as well as bins with higher indices and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) * np.arange(1, len(bins)+1) / (np.arange(1, len(bins)+1) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the bin index divided by the square root of the remaining capacity, favoring bins with lower indices and higher remaining capacity, ensuring a unique scoring approach. In each step, the item will be assigned to the bin with the maximum score until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n capacities = np.sqrt(bins - item)\\n scores = indices / capacities\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the square of the item size by the rest capacity, giving priority to bins with lower rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(item) / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as the rest capacity divided by the square root of the bin number plus one, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity divided by the bin number raised to the power of 1/3, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1) ** (1/3))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the remaining/rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin by dividing the square of the item size by the sum of the rest capacity and the bin index, aiming to prioritize bins with lower indices and higher rest capacity while considering the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on a modified ratio of the rest capacity to the product of the bin index and a user-defined parameter to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.arange(len(bins)) * 2 + 1)) * item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will calculate the score for each bin as the rest capacity divided by the logarithm of the bin number plus one, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.arange(1, len(bins) + 1) + 1)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.sqrt(1 / np.arange(1, len(bins) + 1))\\n scores = (bins * weights) + (item * weights)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the remaining capacity to the square of the bin index plus one, promoting bins with higher remaining capacity and lower indices to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.arange(len(bins))+1)**2 + 1)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the square of the item size by the difference between the rest capacity and the bin index, aiming to prioritize bins with higher indices and lower rest capacity while considering the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(item) / (bins.size - np.arange(1, bins.size+1))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin by dividing the remaining capacity by the bin index, promoting bins with higher rest capacity and lower index, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.arange(1, len(bins) + 1)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by taking the square root of the item size divided by the product of the rest capacity and its index, promoting bins with lower rest capacity and lower index for assignment, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / (bins * np.arange(1, len(bins)+1)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores for bins based on their rest capacity and prioritize bins with higher rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the logarithm of the ratio between the remaining capacity and the bin index, favoring bins with higher rest capacity and lower index, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins/item) - np.log(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin by considering the logarithmic ratio between the item size and the difference between the remaining capacity and a weighted average of the capacities, promoting bins with larger remaining capacity and smaller differences, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n weighted_avg = np.average(bins)\\n differences = max_capacity - weighted_avg\\n ratios = np.log(item / differences)\\n scores = ratios * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores for bins based on their rest capacity and prioritize bins with higher rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the inverse of the bin number multiplied by the rest capacity, returning an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.arange(len(bins)) + 1) * bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Assign bins based on the ratio of the rest capacity to the square root of the bin index, promoting bins with higher remaining capacity and lower index, while penalizing bins with rest capacity equal to the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins)+1))) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.04467,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the product of the rest capacity and the square root of the inverse of the bin number, then return the scores for each bin for assignment, aiming to prioritize bins with lower rest capacity and higher bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity = bins[bins >= item]\\n scores = rest_capacity * np.sqrt(1 / np.arange(len(rest_capacity), 0, -1))\\n return scores\",\n \"objective\": 0.04598,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by taking the square root of the item size minus the product of the rest capacity and the bin index, promoting bins with higher rest capacity and lower index for assignment, while penalizing bins with rest capacity equal to the maximum capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item - (bins * np.arange(1, len(bins)+1)))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n inverse_exponential = np.exp(-bin_indexes)\\n remaining_capacity_power = remaining_capacity ** bin_indexes\\n \\n ratio = item / remaining_capacity\\n \\n scores = inverse_exponential * remaining_capacity_power * ratio\\n\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the product of the item size and the bin index divided by the remaining capacity raised to the power of the bin index multiplied by a constant value, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher value of the constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n constant = 0.5\\n\\n scores = np.log(item * indices) / (remaining_capacity ** indices) * constant\\n scores[remaining_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index and the logarithmic value of the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = bin_index * np.log(remaining_capacity) ** bin_index\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse product of the bin index, the remaining capacity raised to the power of the bin index multiplied by the natural logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with lower index and higher remaining capacity while considering the item's size in relation to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = (1 / index) * (remaining_capacity ** index) * np.log(item / remaining_capacity)\\n return scores\",\n \"objective\": 0.03642,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index, the logarithm of the remaining capacity raised to the power of 2, and the inverse of the item size, aiming to prioritize both bins with higher indices, larger remaining capacities, and smaller item sizes for an optimal bin assignment to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = np.log10(bins - item) ** 2\\n item_size_inverse = 1 / item\\n\\n scores = np.sqrt(bin_indices) + remaining_capacity + item_size_inverse\\n scores[bins == np.max(bins)] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to balance the size of the item, the remaining capacity, and the index of the bin while favoring certain combinations of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * item - bins) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index divided by the inverse square root of the remaining capacity, aiming to balance the index of the bin and the rate of decrease in capacity while favoring bins with higher indices and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n scores[bins == np.amax(bins)] = 0\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will assign a score to each bin based on the ratio of the item size to the rest capacity of the bin minus the product of the bin index and the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n rest_capacity = bins - item\\n \\n scores = (item / rest_capacity) - (index * np.sqrt(index))\\n scores[rest_capacity == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each factor, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n weights = np.array([0.4, 0.3, 0.3]) # Adjust weights as desired\\n \\n scores = indices * weights[0] + remaining_capacity * weights[1] + ratio * weights[2]\\n scores[remaining_capacity == bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin index, the remaining capacity raised to the power of the bin index multiplied by the natural logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with higher index and lower remaining capacity while considering the item's size in relation to the remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins.copy()\\n remaining_capacity[bins == item] = 0\\n scores = np.power(remaining_capacity, indices) * np.log(item / remaining_capacity)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(-bin_indices) + np.exp(-remaining_capacity**bin_indices) + (item/remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n inverse_exponential = np.exp(-bin_indexes)\\n remaining_capacity_power = remaining_capacity ** bin_indexes\\n \\n ratio = item / remaining_capacity\\n \\n scores = inverse_exponential * remaining_capacity_power * ratio\\n\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the product of the item size and the bin index divided by the remaining capacity raised to the power of the bin index multiplied by a constant value, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher value of the constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n constant = 0.5\\n\\n scores = np.log(item * indices) / (remaining_capacity ** indices) * constant\\n scores[remaining_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the logarithm of the bin index, the square root of the remaining capacity raised to the power of the bin index, and the cube of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins)+1)\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n \\n scores = np.log(bin_index) + np.sqrt(remaining_capacity)**bin_index + ratio**3\\n scores[remaining_capacity == np.max(bins)-item] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index and the logarithmic value of the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = bin_index * np.log(remaining_capacity) ** bin_index\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the bin index and the remaining capacity multiplied by the square root of the quotient between the bin index and the remaining capacity, aiming to balance the index of the bin, the remaining capacity, and the rate of decrease in capacity with increasing index while favoring bins with higher indices and lower rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n \\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the bin indices\\n bin_indices = np.arange(bin_count) + 1\\n \\n # Calculate the score for each bin\\n scores = (bin_indices + remaining_capacity) * np.sqrt(bin_indices / remaining_capacity)\\n \\n # Set scores of bins with maximum capacity to -inf to exclude them from being used\\n scores[remaining_capacity == np.max(remaining_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the logarithm of the bin index, the square root of the remaining capacity raised to the power of the bin index, and the product of the item size and the inverse of the rest capacity, aiming to balance the index and capacity factors while favoring bins with lower index and larger remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n \\n scores = np.log(bin_index) + np.sqrt(remaining_capacity) ** bin_index + (item * (1 / remaining_capacity))\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse product of the bin index, the remaining capacity raised to the power of the bin index multiplied by the natural logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with lower index and higher remaining capacity while considering the item's size in relation to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = (1 / index) * (remaining_capacity ** index) * np.log(item / remaining_capacity)\\n return scores\",\n \"objective\": 0.03642,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the bin index, the logarithm of the remaining capacity raised to the power of 2, and the inverse of the item size, aiming to prioritize both bins with higher indices, larger remaining capacities, and smaller item sizes for an optimal bin assignment to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = np.log10(bins - item) ** 2\\n item_size_inverse = 1 / item\\n\\n scores = np.sqrt(bin_indices) + remaining_capacity + item_size_inverse\\n scores[bins == np.max(bins)] = -np.inf\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square of the remaining capacity divided by the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity with a non-linear relationship.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n \\n scores = np.log(bin_index) * (remaining_capacity**2 / bin_index) * (item / remaining_capacity)\\n \\n # Filter out bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[remaining_capacity == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each factor, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n weights = np.array([0.4, 0.3, 0.3]) # Adjust weights as desired\\n \\n scores = indices * weights[0] + remaining_capacity * weights[1] + ratio * weights[2]\\n scores[remaining_capacity == bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin index, the remaining capacity raised to the power of the bin index multiplied by the natural logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with higher index and lower remaining capacity while considering the item's size in relation to the remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins.copy()\\n remaining_capacity[bins == item] = 0\\n scores = np.power(remaining_capacity, indices) * np.log(item / remaining_capacity)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(-bin_indices) + np.exp(-remaining_capacity**bin_indices) + (item/remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n inverse_exponential = np.exp(-bin_indexes)\\n remaining_capacity_power = remaining_capacity ** bin_indexes\\n \\n ratio = item / remaining_capacity\\n \\n scores = inverse_exponential * remaining_capacity_power * ratio\\n\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the sine function of the bin index, the cosine function of the remaining capacity raised to the power of the inverse bin index, and the logarithm of the item size, in order to incorporate trigonometric and logarithmic functions for a unique scoring approach while considering the bin index, remaining capacity, and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n inverse_bin_index = 1 / (bin_index + 1)\\n scores = np.sin(bin_index) * np.cos(remaining_capacity**inverse_bin_index) * np.log(item)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square root of the remaining capacity raised to the power of the bin index, and the inverse of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n \\n scores = np.log(index) * np.sqrt(remaining_capacity)**index * (item / remaining_capacity)\\n \\n # Set score to 0 for bins with maximum capacity\\n scores[remaining_capacity == bins] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the product of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the remaining capacity, aiming to balance the size and capacity factors while giving higher priority to bins with higher index and higher remaining capacity and favoring a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n scores = np.sqrt(bin_indexes * remaining_capacity**bin_indexes * (item / remaining_capacity))\\n scores[remaining_capacity == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the product of the item size and the bin index divided by the remaining capacity raised to the power of the bin index multiplied by a constant value, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher value of the constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n constant = 0.5\\n\\n scores = np.log(item * indices) / (remaining_capacity ** indices) * constant\\n scores[remaining_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the square root of the bin index, the logarithm of the remaining capacity raised to the power of the bin index, and the product of the item size and the inverse of the rest capacity, aiming to prioritize bins with lower index, larger remaining capacity, and penalize bins with smaller remaining capacity by introducing logarithmic scaling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.sqrt(bin_indices) * np.log(remaining_capacity) ** bin_indices * item / remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index raised to the power of the item size, divided by the square root of the remaining capacity, aiming to optimize the balance between item size, bin index, and remaining capacity for effective bin assignment in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_capacities = np.sqrt(bins - item)\\n scores = (bin_indices ** item) / remaining_capacities\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the logarithm of the bin index, the square root of the remaining capacity raised to the power of the bin index, and the cube of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins)+1)\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n \\n scores = np.log(bin_index) + np.sqrt(remaining_capacity)**bin_index + ratio**3\\n scores[remaining_capacity == np.max(bins)-item] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the product of the bin index and the logarithmic value of the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = bin_index * np.log(remaining_capacity) ** bin_index\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square of the remaining capacity divided by the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity with a non-linear relationship.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n \\n scores = np.log(bin_index) * (remaining_capacity**2 / bin_index) * (item / remaining_capacity)\\n \\n # Filter out bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[remaining_capacity == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each factor, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n weights = np.array([0.4, 0.3, 0.3]) # Adjust weights as desired\\n \\n scores = indices * weights[0] + remaining_capacity * weights[1] + ratio * weights[2]\\n scores[remaining_capacity == bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin index, the remaining capacity raised to the power of the bin index multiplied by the natural logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with higher index and lower remaining capacity while considering the item's size in relation to the remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins.copy()\\n remaining_capacity[bins == item] = 0\\n scores = np.power(remaining_capacity, indices) * np.log(item / remaining_capacity)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(-bin_indices) + np.exp(-remaining_capacity**bin_indices) + (item/remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the bin index, the remaining capacity divided by the bin index, and the square root of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = np.log(indices) + remaining_capacity / indices + np.sqrt(item / remaining_capacity)\\n scores[remaining_capacity == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the squared ratio of the item size to the rest capacity, divided by the bin index raised to the power of the inverse of the remaining capacity, aiming to favor bins with lower index and higher rest capacity, while penalizing larger items relative to the available space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_caps = bins - item\\n\\n scores = np.log((item**2 / remaining_caps)) / (bin_indices**remaining_caps)\\n\\n return scores\",\n \"objective\": 0.02465,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n inverse_exponential = np.exp(-bin_indexes)\\n remaining_capacity_power = remaining_capacity ** bin_indexes\\n \\n ratio = item / remaining_capacity\\n \\n scores = inverse_exponential * remaining_capacity_power * ratio\\n\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the sine function of the bin index, the cosine function of the remaining capacity raised to the power of the inverse bin index, and the logarithm of the item size, in order to incorporate trigonometric and logarithmic functions for a unique scoring approach while considering the bin index, remaining capacity, and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n inverse_bin_index = 1 / (bin_index + 1)\\n scores = np.sin(bin_index) * np.cos(remaining_capacity**inverse_bin_index) * np.log(item)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the absolute differences between the bin index and the remaining capacity, multiplied by the logarithm of the ratio of the item size to the rest capacity, aiming to prioritize both the proximity of the bin to its original index and the suitability of the available space for the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_diff = np.abs(np.arange(len(bins)) - bins)\\n ratio = np.log(item / bins)\\n scores = index_diff * ratio\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square root of the remaining capacity raised to the power of the bin index, and the inverse of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n \\n scores = np.log(index) * np.sqrt(remaining_capacity)**index * (item / remaining_capacity)\\n \\n # Set score to 0 for bins with maximum capacity\\n scores[remaining_capacity == bins] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the product of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the remaining capacity, aiming to balance the size and capacity factors while giving higher priority to bins with higher index and higher remaining capacity and favoring a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n scores = np.sqrt(bin_indexes * remaining_capacity**bin_indexes * (item / remaining_capacity))\\n scores[remaining_capacity == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the product of the item size and the bin index divided by the remaining capacity raised to the power of the bin index multiplied by a constant value, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher value of the constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n constant = 0.5\\n\\n scores = np.log(item * indices) / (remaining_capacity ** indices) * constant\\n scores[remaining_capacity == bins] = -np.inf\\n\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the square root of the bin index, the logarithm of the remaining capacity raised to the power of the bin index, and the product of the item size and the inverse of the rest capacity, aiming to prioritize bins with lower index, larger remaining capacity, and penalize bins with smaller remaining capacity by introducing logarithmic scaling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.sqrt(bin_indices) * np.log(remaining_capacity) ** bin_indices * item / remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square of the remaining capacity divided by the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity with a non-linear relationship.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n \\n scores = np.log(bin_index) * (remaining_capacity**2 / bin_index) * (item / remaining_capacity)\\n \\n # Filter out bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[remaining_capacity == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each factor, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n weights = np.array([0.4, 0.3, 0.3]) # Adjust weights as desired\\n \\n scores = indices * weights[0] + remaining_capacity * weights[1] + ratio * weights[2]\\n scores[remaining_capacity == bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, aiming to achieve a balanced score that takes into account all three factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(bins.size)\\n bin_ratio = item / (bins - item)\\n scores = bin_index + bins + bin_ratio\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin index, the remaining capacity raised to the power of the bin index multiplied by the natural logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with higher index and lower remaining capacity while considering the item's size in relation to the remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins.copy()\\n remaining_capacity[bins == item] = 0\\n scores = np.power(remaining_capacity, indices) * np.log(item / remaining_capacity)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(-bin_indices) + np.exp(-remaining_capacity**bin_indices) + (item/remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the logarithm of the bin index, the cube of the remaining capacity divided by the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity with a non-linear relationship.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(1, len(bins) + 1)\\n remaining_capacities = bins - item\\n scores = np.log(indices) + (remaining_capacities**3 / indices) + (item / remaining_capacities)\\n scores[remaining_capacities == bins] = -np.inf\\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the bin index, the remaining capacity divided by the bin index, and the square root of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = np.log(indices) + remaining_capacity / indices + np.sqrt(item / remaining_capacity)\\n scores[remaining_capacity == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the squared ratio of the item size to the rest capacity, divided by the bin index raised to the power of the inverse of the remaining capacity, aiming to favor bins with lower index and higher rest capacity, while penalizing larger items relative to the available space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_caps = bins - item\\n\\n scores = np.log((item**2 / remaining_caps)) / (bin_indices**remaining_caps)\\n\\n return scores\",\n \"objective\": 0.02465,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n inverse_exponential = np.exp(-bin_indexes)\\n remaining_capacity_power = remaining_capacity ** bin_indexes\\n \\n ratio = item / remaining_capacity\\n \\n scores = inverse_exponential * remaining_capacity_power * ratio\\n\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the sine function of the bin index, the cosine function of the remaining capacity raised to the power of the inverse bin index, and the logarithm of the item size, in order to incorporate trigonometric and logarithmic functions for a unique scoring approach while considering the bin index, remaining capacity, and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n inverse_bin_index = 1 / (bin_index + 1)\\n scores = np.sin(bin_index) * np.cos(remaining_capacity**inverse_bin_index) * np.log(item)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the absolute differences between the bin index and the remaining capacity, multiplied by the logarithm of the ratio of the item size to the rest capacity, aiming to prioritize both the proximity of the bin to its original index and the suitability of the available space for the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_diff = np.abs(np.arange(len(bins)) - bins)\\n ratio = np.log(item / bins)\\n scores = index_diff * ratio\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, two times the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n exponential_values = np.exp(-bin_index)\\n capacity_factor = 2 * np.power(remaining_capacity, bin_index)\\n size_factor = item / remaining_capacity\\n \\n scores = exponential_values * capacity_factor * size_factor\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square root of the remaining capacity raised to the power of the bin index, and the inverse of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n \\n scores = np.log(index) * np.sqrt(remaining_capacity)**index * (item / remaining_capacity)\\n \\n # Set score to 0 for bins with maximum capacity\\n scores[remaining_capacity == bins] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the product of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the remaining capacity, aiming to balance the size and capacity factors while giving higher priority to bins with higher index and higher remaining capacity and favoring a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n scores = np.sqrt(bin_indexes * remaining_capacity**bin_indexes * (item / remaining_capacity))\\n scores[remaining_capacity == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin by calculating the sum of the bin index divided by the remaining capacity raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = indices / np.power(remaining_capacity, indices)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square of the remaining capacity divided by the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity with a non-linear relationship.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n \\n scores = np.log(bin_index) * (remaining_capacity**2 / bin_index) * (item / remaining_capacity)\\n \\n # Filter out bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[remaining_capacity == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each factor, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n weights = np.array([0.4, 0.3, 0.3]) # Adjust weights as desired\\n \\n scores = indices * weights[0] + remaining_capacity * weights[1] + ratio * weights[2]\\n scores[remaining_capacity == bins] = -np.inf\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, aiming to achieve a balanced score that takes into account all three factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(bins.size)\\n bin_ratio = item / (bins - item)\\n scores = bin_index + bins + bin_ratio\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin index, the remaining capacity raised to the power of the bin index multiplied by the natural logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with higher index and lower remaining capacity while considering the item's size in relation to the remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacity = bins.copy()\\n remaining_capacity[bins == item] = 0\\n scores = np.power(remaining_capacity, indices) * np.log(item / remaining_capacity)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(-bin_indices) + np.exp(-remaining_capacity**bin_indices) + (item/remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the sum of the logarithm of the bin index, the cube of the remaining capacity divided by the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity with a non-linear relationship.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(1, len(bins) + 1)\\n remaining_capacities = bins - item\\n scores = np.log(indices) + (remaining_capacities**3 / indices) + (item / remaining_capacities)\\n scores[remaining_capacities == bins] = -np.inf\\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the reciprocal of the bin index, the difference between the remaining capacity and the item size divided by the bin index, and the square of the logarithm of the ratio of the item size to the rest capacity, aiming to prioritize bins with lower index, higher remaining capacity relative to item size, and a non-linear relationship between item size and available space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(1, len(bins)+1)\\n remaining_capacity = bins - item\\n ratio = item / remaining_capacity\\n \\n scores = 1/bin_indices + remaining_capacity/bin_indices + np.log(ratio)**2\\n \\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the bin index, the remaining capacity divided by the bin index, and the square root of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = np.log(indices) + remaining_capacity / indices + np.sqrt(item / remaining_capacity)\\n scores[remaining_capacity == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the squared ratio of the item size to the rest capacity, divided by the bin index raised to the power of the inverse of the remaining capacity, aiming to favor bins with lower index and higher rest capacity, while penalizing larger items relative to the available space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n bin_indices = np.arange(len(bins)) + 1\\n remaining_caps = bins - item\\n\\n scores = np.log((item**2 / remaining_caps)) / (bin_indices**remaining_caps)\\n\\n return scores\",\n \"objective\": 0.02465,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n inverse_exponential = np.exp(-bin_indexes)\\n remaining_capacity_power = remaining_capacity ** bin_indexes\\n \\n ratio = item / remaining_capacity\\n \\n scores = inverse_exponential * remaining_capacity_power * ratio\\n\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the sine function of the bin index, the cosine function of the remaining capacity raised to the power of the inverse bin index, and the logarithm of the item size, in order to incorporate trigonometric and logarithmic functions for a unique scoring approach while considering the bin index, remaining capacity, and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n inverse_bin_index = 1 / (bin_index + 1)\\n scores = np.sin(bin_index) * np.cos(remaining_capacity**inverse_bin_index) * np.log(item)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the absolute differences between the bin index and the remaining capacity, multiplied by the logarithm of the ratio of the item size to the rest capacity, aiming to prioritize both the proximity of the bin to its original index and the suitability of the available space for the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_diff = np.abs(np.arange(len(bins)) - bins)\\n ratio = np.log(item / bins)\\n scores = index_diff * ratio\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse of the bin index multiplied by the logarithm of the ratio of the item size to the remaining capacity, aiming to favor bins with lower index and larger remaining capacity while considering the item's size in relation to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=np.float64)\\n max_capacity = np.max(bins)\\n \\n if max_capacity == bins[0]:\\n scores[1:] = np.log(item / bins[1:])\\n\\n else:\\n scores[0] = 1 / (np.log(item / max_capacity) + 1)\\n scores[1:] = (1 / np.arange(2, len(bins) + 1)) * np.log(item / bins[1:])\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the inverse exponential values of the bin index, two times the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n exponential_values = np.exp(-bin_index)\\n capacity_factor = 2 * np.power(remaining_capacity, bin_index)\\n size_factor = item / remaining_capacity\\n \\n scores = exponential_values * capacity_factor * size_factor\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the logarithm of the bin index, the square root of the remaining capacity raised to the power of the bin index, and the inverse of the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with lower index and lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n \\n scores = np.log(index) * np.sqrt(remaining_capacity)**index * (item / remaining_capacity)\\n \\n # Set score to 0 for bins with maximum capacity\\n scores[remaining_capacity == bins] = 0\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the exponential values of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the rest capacity, aiming to balance the size and capacity factors while favoring bins with higher index and higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = np.exp(bin_indices) * np.power(remaining_capacity, bin_indices) * (item / remaining_capacity)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin index, the remaining capacity, and the ratio of the item size to the rest capacity, with specific weights assigned to each of these factors, in order to achieve a balanced scoring system that minimizes the number of used bins while considering the size and capacity differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins.astype(float) - item)\\n \\n # Define weights for bin index, remaining capacity, and ratio of item size to capacity\\n index_weight = 0.4\\n capacity_weight = 0.3\\n ratio_weight = 0.3\\n \\n # Calculate the scores for each bin using the defined weights and factors\\n scores = index_weight * np.arange(len(bins)) + capacity_weight * bins + ratio_weight * ratios\\n \\n # Set scores of bins with maximum capacity to a very low value to avoid their selection\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the product of the bin index, the remaining capacity raised to the power of the bin index, and the ratio of the item size to the remaining capacity, aiming to balance the size and capacity factors while giving higher priority to bins with higher index and higher remaining capacity and favoring a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indexes = np.arange(len(bins)) + 1\\n remaining_capacity = bins - item\\n scores = np.sqrt(bin_indexes * remaining_capacity**bin_indexes * (item / remaining_capacity))\\n scores[remaining_capacity == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = (item * bin_indices) / (np.exp(remaining_capacity) ** bin_indices)\\n scores[remaining_capacity == bins] = 0\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the bin index divided by the square root of the remaining capacity, favoring bins with lower indices and higher remaining capacity, ensuring a unique scoring approach. In each step, the item will be assigned to the bin with the maximum score until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n capacities = np.sqrt(bins - item)\\n scores = indices / capacities\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as the rest capacity divided by the square root of the bin number plus one, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity divided by the bin number raised to the power of 1/3, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1) ** (1/3))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the remaining/rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin by dividing the square of the item size by the sum of the rest capacity and the bin index, aiming to prioritize bins with lower indices and higher rest capacity while considering the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on a modified ratio of the rest capacity to the product of the bin index and a user-defined parameter to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.arange(len(bins)) * 2 + 1)) * item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will calculate the score for each bin as the rest capacity divided by the logarithm of the bin number plus one, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.arange(1, len(bins) + 1) + 1)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.sqrt(1 / np.arange(1, len(bins) + 1))\\n scores = (bins * weights) + (item * weights)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the product of the item size and the bin index divided by the sum of the rest capacity and the square of the bin index plus one, aiming to balance the size of the item, the remaining capacity, and the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n scores = (item * index) / (bins + index**2 + 1)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the remaining capacity to the square of the bin index plus one, promoting bins with higher remaining capacity and lower indices to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.arange(len(bins))+1)**2 + 1)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the inverse of the rest capacity, this time giving priority to bins with higher rest capacity, and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.reciprocal(bins)).astype(np.float32)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin by dividing the remaining capacity by the bin index, promoting bins with higher rest capacity and lower index, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.arange(1, len(bins) + 1)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the item size and the square root of the remaining capacity divided by the bin index plus one, aiming to prioritize smaller items with higher remaining capacity and favoring bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.sqrt(bins) / (np.arange(len(bins), dtype=float) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores for bins based on their rest capacity and prioritize bins with higher rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the logarithm of the ratio between the remaining capacity and the bin index, favoring bins with higher rest capacity and lower index, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins/item) - np.log(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the product of the item size and the bin index divided by the sum of the rest capacity and the square of the bin index minus one, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n denominator = rest_capacity + bin_indices**2 - 1\\n scores = item * bin_indices / denominator\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the square root of the ratio of the item size to the rest capacity of the bin raised to the power of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) ** (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the bin index divided by the square root of the remaining capacity, favoring bins with lower indices and higher remaining capacity, ensuring a unique scoring approach. In each step, the item will be assigned to the bin with the maximum score until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n capacities = np.sqrt(bins - item)\\n scores = indices / capacities\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the rest capacity by the square root of the bin index plus one, aiming to prioritize bins with both higher rest capacity and lower index while considering the index of the bin in the calculation of the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(bins.size) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity divided by the bin number raised to the power of 1/3, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1) ** (1/3))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the remaining/rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin by dividing the square of the item size by the sum of the rest capacity and the bin index, aiming to prioritize bins with lower indices and higher rest capacity while considering the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2) / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on a modified ratio of the rest capacity to the product of the bin index and a user-defined parameter to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.arange(len(bins)) * 2 + 1)) * item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will calculate the score for each bin as the rest capacity divided by the logarithm of the bin number plus one, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.arange(1, len(bins) + 1) + 1)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.sqrt(1 / np.arange(1, len(bins) + 1))\\n scores = (bins * weights) + (item * weights)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the product of the item size and the bin index divided by the sum of the rest capacity and the square of the bin index plus one, aiming to balance the size of the item, the remaining capacity, and the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n scores = (item * index) / (bins + index**2 + 1)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the remaining capacity to the square of the bin index plus one, promoting bins with higher remaining capacity and lower indices to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.arange(len(bins))+1)**2 + 1)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the inverse of the rest capacity, this time giving priority to bins with higher rest capacity, and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.reciprocal(bins)).astype(np.float32)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin by dividing the remaining capacity by the bin index, promoting bins with higher rest capacity and lower index, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.arange(1, len(bins) + 1)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the item size and the square root of the remaining capacity divided by the bin index plus one, aiming to prioritize smaller items with higher remaining capacity and favoring bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.sqrt(bins) / (np.arange(len(bins), dtype=float) + 1))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculate scores for bins based on their rest capacity and prioritize bins with higher rest capacity.}\\n\\n{New algorithm: The score function will calculate the scores for each bin based on the logarithm of the ratio between the remaining capacity and the bin index, favoring bins with higher rest capacity and lower index, while penalizing bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins/item) - np.log(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the product of the item size and the bin index divided by the sum of the rest capacity and the square of the bin index minus one, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n rest_capacity = bins - item\\n denominator = rest_capacity + bin_indices**2 - 1\\n scores = item * bin_indices / denominator\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the square root of the ratio of the item size to the rest capacity of the bin raised to the power of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) ** (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the bin index divided by the square root of the remaining capacity, favoring bins with lower indices and higher remaining capacity, ensuring a unique scoring approach. In each step, the item will be assigned to the bin with the maximum score until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n capacities = np.sqrt(bins - item)\\n scores = indices / capacities\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the rest capacity by the square root of the bin index plus one, aiming to prioritize bins with both higher rest capacity and lower index while considering the index of the bin in the calculation of the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(np.arange(bins.size) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity divided by the bin number raised to the power of 1/3, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1) ** (1/3))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns bins based on the quotient between the item's size and the sum of the rest capacity and the bin index, guaranteeing that larger items will be placed in bins with higher remaining capacity and lower index values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the item size to the square of the bin index plus one, divided by the sum of the rest capacity and the bin index, aiming to prioritize the size of the item and the index of the bin over the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(bins.size)\\n rest_capacity = bins - item\\n scores = (item / (bin_indices**2 + 1)) / (rest_capacity + bin_indices)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on a modified ratio of the rest capacity to the product of the bin index and a user-defined parameter to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.arange(len(bins)) * 2 + 1)) * item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will calculate the score for each bin as the rest capacity divided by the logarithm of the bin number plus one, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.arange(1, len(bins) + 1) + 1)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.sqrt(1 / np.arange(1, len(bins) + 1))\\n scores = (bins * weights) + (item * weights)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the product of the item size and the bin index divided by the sum of the rest capacity and the square of the bin index plus one, aiming to balance the size of the item, the remaining capacity, and the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n scores = (item * index) / (bins + index**2 + 1)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the remaining capacity to the square of the bin index plus one, promoting bins with higher remaining capacity and lower indices to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.arange(len(bins))+1)**2 + 1)) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The score function calculates scores for each bin based on the remaining capacity and the item size.}\\n\\n{New algorithm: The score function will calculate the scores for each bin by taking the minimum of the square root of the item size and the remaining capacity, emphasizing bins with more remaining capacity and smaller items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(np.sqrt(item), bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the inverse of the rest capacity divided by the sum of the bin index and a user-defined parameter to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins).astype(float)\\n max_capacity = max(bins)\\n denominator = np.arange(len(bins)) + 1\\n scores = (max_capacity - bins) / (denominator + 1)\\n scores[denominator == max_capacity] = 0\\n scores /= np.sum(scores)\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the square root of the ratio of the item size to the rest capacity of the bin raised to the power of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) ** (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the sum of the rest capacity and a user-defined parameter to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n # Calculate the ratio of the sum of rest capacity to the square root of bin index\\n ratio = np.sum(rest_capacity) / np.sqrt(np.arange(1, num_bins+1))\\n \\n # Assign scores based on the ratio\\n scores = ratio / rest_capacity\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the bin index divided by the square root of the remaining capacity, favoring bins with lower indices and higher remaining capacity, ensuring a unique scoring approach. In each step, the item will be assigned to the bin with the maximum score until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n capacities = np.sqrt(bins - item)\\n scores = indices / capacities\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the exponential function of the item size divided by the sum of the rest capacity and the logarithm of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(item / (bins + np.log(range(1, len(bins)+1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the rest capacity to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins) + 1))) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity divided by the bin number raised to the power of 1/3, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1) ** (1/3))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns bins based on the quotient between the item's size and the sum of the rest capacity and the bin index, guaranteeing that larger items will be placed in bins with higher remaining capacity and lower index values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the item size to the square of the bin index plus one, divided by the sum of the rest capacity and the bin index, aiming to prioritize the size of the item and the index of the bin over the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(bins.size)\\n rest_capacity = bins - item\\n scores = (item / (bin_indices**2 + 1)) / (rest_capacity + bin_indices)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on a modified ratio of the rest capacity to the product of the bin index and a user-defined parameter to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.arange(len(bins)) * 2 + 1)) * item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm will calculate the score for each bin as the rest capacity divided by the logarithm of the bin number plus one, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.arange(1, len(bins) + 1) + 1)\\n scores[bins == max(bins)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on a weighted average of the rest capacity and the inverse of the square root of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.sqrt(1 / np.arange(1, len(bins) + 1))\\n scores = (bins * weights) + (item * weights)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the product of the item size and the bin index divided by the sum of the rest capacity and the square of the bin index plus one, aiming to balance the size of the item, the remaining capacity, and the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins)) + 1\\n scores = (item * index) / (bins + index**2 + 1)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will assign bins based on the square root of the product of the item size and the bin index, divided by the sum of the remainder capacity and the square of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins))\\n \\n scores = np.sqrt(item * bin_indices) / (bins + bin_indices**2)\\n \\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the square root of the ratio of the item size to the rest capacity of the bin raised to the power of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) ** (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the sum of the rest capacity and a user-defined parameter to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n # Calculate the ratio of the sum of rest capacity to the square root of bin index\\n ratio = np.sum(rest_capacity) / np.sqrt(np.arange(1, num_bins+1))\\n \\n # Assign scores based on the ratio\\n scores = ratio / rest_capacity\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the bin index divided by the square root of the remaining capacity, favoring bins with lower indices and higher remaining capacity, ensuring a unique scoring approach. In each step, the item will be assigned to the bin with the maximum score until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n capacities = np.sqrt(bins - item)\\n scores = indices / capacities\\n scores[bins == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using a combination of the item size, bin index, and rest capacity, the new algorithm assigns bins based on a logarithmic function with adjustable parameters, aiming to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = np.log(item) / np.log(rest_capacity / (max_capacity - rest_capacity))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the exponential function of the item size divided by the sum of the rest capacity and the logarithm of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(item / (bins + np.log(range(1, len(bins)+1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"T\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=int)\\n max_capacity = np.max(bins)\\n\\n # Calculate score for each bin\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1 # Not using bins with maximum capacity\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n scores[i] = remaining_capacity - item\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the rest capacity to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins) + 1))) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio of the bin index subtracted by the square root of the remaining capacity, aiming to prioritize bins with lower indices and higher remaining capacities for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = np.sqrt(bins - item)\\n scores = indices - remaining_capacities\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity divided by the bin number raised to the power of 1/3, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1) ** (1/3))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns bins based on the quotient between the item's size and the sum of the rest capacity and the bin index, guaranteeing that larger items will be placed in bins with higher remaining capacity and lower index values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the item size to the square of the bin index plus one, divided by the sum of the rest capacity and the bin index, aiming to prioritize the size of the item and the index of the bin over the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(bins.size)\\n rest_capacity = bins - item\\n scores = (item / (bin_indices**2 + 1)) / (rest_capacity + bin_indices)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the sum of the rest capacity and a user-defined parameter to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n # Calculate the ratio of the sum of rest capacity to the square root of bin index\\n ratio = np.sum(rest_capacity) / np.sqrt(np.arange(1, num_bins+1))\\n \\n # Assign scores based on the ratio\\n scores = ratio / rest_capacity\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin index squared and the inverse of the remaining capacity, aiming to prioritize bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = indices ** 2 / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Using a combination of the item size, bin index, and rest capacity, the new algorithm assigns bins based on a logarithmic function with adjustable parameters, aiming to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = np.log(item) / np.log(rest_capacity / (max_capacity - rest_capacity))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the exponential function of the item size divided by the sum of the rest capacity and the logarithm of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(item / (bins + np.log(range(1, len(bins)+1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the logarithmic function of the item size divided by the sum of the rest capacity and the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n size_ratio = np.log(item) / np.log(2)\\n rest_ratio = (bins / np.sum(bins)) ** 2\\n index_ratio = (np.arange(1, len(bins) + 1) / len(bins)) ** 3\\n \\n scores = size_ratio / (rest_ratio + index_ratio)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the rest capacity to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins) + 1))) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio of the bin index subtracted by the square root of the remaining capacity, aiming to prioritize bins with lower indices and higher remaining capacities for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = np.sqrt(bins - item)\\n scores = indices - remaining_capacities\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity divided by the bin number raised to the power of 1/3, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(1, len(bins)+1) ** (1/3))\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns bins based on the quotient between the item's size and the sum of the rest capacity and the bin index, guaranteeing that larger items will be placed in bins with higher remaining capacity and lower index values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the item size to the square of the bin index plus one, divided by the sum of the rest capacity and the bin index, aiming to prioritize the size of the item and the index of the bin over the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(bins.size)\\n rest_capacity = bins - item\\n scores = (item / (bin_indices**2 + 1)) / (rest_capacity + bin_indices)\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_CoevolutionThoughts&Codes/T2T2C/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalizing bins with maximum capacity and also considering the number of items already assigned to each bin, to further reduce the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items = np.ceil(remaining_capacity/item)\\n \\n # Calculate the score for each bin\\n scores = remaining_capacity - (assigned_items - 1) * item\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the bin index multiplied by a constant factor, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a lower rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index = np.arange(len(bins))\\n remaining_capacity = bins - item\\n scores = np.exp(item * index / (remaining_capacity**index * 0.5))\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, lower index, and a lower value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 0.5\\n bin_index = np.arange(1, len(bins) + 1)\\n rest_capacity_index = (bins - item) ** bin_index\\n scores = (item * bin_index) / (rest_capacity_index * k)\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the product of the item size and the bin index by the rest capacity raised to the power of the bin index multiplied by a constant value k, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity, higher index, and a higher value of k.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2 # Constant value\\n bin_index = np.arange(len(bins))\\n rest_capacity_indexed = bins - item\\n scores = (item * bin_index) / (rest_capacity_indexed**bin_index * k)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses the bin index cubed as a factor in the score function to give higher priority to bins with higher indices and lower remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 3) / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the square root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_indices = np.arange(len(bins)) + 1 # bin index starts from 1\\n remainder_capacity = bins - item\\n\\n scores = (item * np.exp(bin_indices))/(remainder_capacity**np.sqrt(bin_indices))\\n scores[remainder_capacity == bins] = 0 # Ignore bins with full capacity\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin index squared plus the inverse of the remaining capacity, aiming to prioritize both bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n remaining_capacities = bins - item\\n \\n scores = indices ** 2 + (1 / remaining_capacities)\\n \\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin minus the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the item size and the bin index divided by the exponential function of the rest capacity raised to the power of the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n remaining_capacity = bins - item\\n scores = (item * bin_index) / (np.exp(remaining_capacity) ** np.sqrt(bin_index))\\n scores[remaining_capacity == max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the ratio of the item size to the rest capacity of the bin plus the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n max_capacity = np.max(bins)\\n \\n for i, rest_capacity in enumerate(bins):\\n if rest_capacity == max_capacity:\\n scores[i] = float('-inf')\\n else:\\n scores[i] = item / (rest_capacity - item) + np.sqrt(i)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the item size and the rest capacity, divided by the sum of the bin index and a constant value, aiming to prioritize bins with lower remaining capacity and lower index while addressing the size of the item and providing a constant factor to balance the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item - bins) / (np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function calculates the scores for each bin based on the logarithm of the ratio of the item size to the rest capacity of the bin, multiplied by the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with lower remaining capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item / bins) * (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the ratio between the item size and the remaining capacity, multiplied by the square root of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, larger remaining capacity, and a greater difference between the item size and remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item/bins) * np.sqrt(np.arange(1, len(bins)+1))\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the sum of the rest capacity and a user-defined parameter to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n rest_capacity = bins - item\\n \\n # Calculate the ratio of the sum of rest capacity to the square root of bin index\\n ratio = np.sum(rest_capacity) / np.sqrt(np.arange(1, num_bins+1))\\n \\n # Assign scores based on the ratio\\n scores = ratio / rest_capacity\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the bin index squared and the inverse of the remaining capacity, aiming to prioritize bins with higher indices and lower remaining capacities while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = indices ** 2 / (bins - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin by dividing the item size by the rest capacity, giving priority to bins with higher rest capacity and returning the scores as a Numpy array for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm assigns scores to each bin based on the logarithm of the item size multiplied by the bin index, divided by the remainder capacity raised to the power of the cube root of the bin index, in order to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher index, higher rest capacity, and a higher rate of decrease in capacity with increasing index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) * np.arange(len(bins))\\n scores /= bins**(1/3)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the exponential function of the item size divided by the sum of the rest capacity and the logarithm of the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(item / (bins + np.log(range(1, len(bins)+1))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the logarithmic function of the item size divided by the sum of the rest capacity and the bin index, aiming to balance the size of the item, the remaining capacity, and the index of the bin while favoring bins with higher rest capacity and higher index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n size_ratio = np.log(item) / np.log(2)\\n rest_ratio = (bins / np.sum(bins)) ** 2\\n index_ratio = (np.arange(1, len(bins) + 1) / len(bins)) ** 3\\n \\n scores = size_ratio / (rest_ratio + index_ratio)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns bins based on the ratio of the rest capacity to the square root of the bin index, with the aim of optimizing the assignment and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.arange(1, len(bins) + 1))) * (bins != np.max(bins))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account both these parameters.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The scoring method is modified by incorporating both the rest capacity and the number of items of each bin. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1)) + (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1)) * (np.sum(bins != 0) / (np.sum(bins != 0) + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. The new algorithm modifies the scoring method by taking into account both the rest capacity of the bin and the number of items already assigned to the bin.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity of each bin and the number of items already assigned to the bin. The scoring function is adjusted by incorporating a weighting factor that is determined based on the product of the rest capacity and the number of items already assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 - ((bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))) * (bins[bins != bins.max()] * (bins[bins != bins.max()] != 0))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity of each bin and the cost of assigning the item to the bin, in order to minimize the number of used bins. The cost of assigning the item to a bin is calculated as the product of the item size and the ratio of the item size to the bin capacity, and a smaller cost indicates a better fit.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n ratios = item / bins.astype(float)\\n costs = item * ratios\\n scores[bins != bins.max()] = costs[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is modified to assign scores to the bins based on the following steps: calculate the ratio of item size to bin capacity, calculate the number of used bins, assign weights based on the number of used bins and ratio, and then calculate the scores for each bin based on the modified score formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n \\n used_bins = np.count_nonzero(bins < max_capacity)\\n weights = 0.8 * used_bins + 0.2 * ratio\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(1.5 * ratio[i] * bins[i] * weights[i])\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm will calculate the score for each bin by considering both the ratio of item size to bin capacity and the number of used bins for previous assignments. The score will be a weighted sum of these two factors, with more weight given to the number of used bins to prioritize the minimization of used bins. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n\\n used_bins = np.count_nonzero(scores)\\n weights = 0.8 * used_bins + 0.2 * ratio\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(ratio[i] * bins[i] * weights[i])\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the ratio of item size to bin capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n ratios = item / bins.astype(float)\\n scores[bins != bins.max()] = ratios[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) ** 2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n \\n used_bins = np.count_nonzero(scores)\\n weights = 0.9 * used_bins + 0.1 * ratio\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(1.2 * ratio[i] * bins[i] * weights[i])\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: Modified Algorithm Description: \\nIn this modified algorithm, the score function will assign items to bins based on a modified score function that takes into account the bin capacity, the item size, and the number of items already assigned to a bin. Each bin will be assigned the item with the maximum modified score, and empty bins with maximum capacity will not be used. The goal is still to minimize the number of used bins, but the modified score function will prioritize bins with lower capacity, fewer items already assigned to them, and a higher ratio of item size to bin capacity. \\n\\nModified Algorithm Implementation:\\n\\n```\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Calculate the maximum capacity and its count\\n max_capacity = np.max(bins)\\n max_capacity_count = np.count_nonzero(bins == max_capacity)\\n \\n # Calculate the number of items already assigned to each bin\\n assigned_items_count = np.zeros_like(bins)\\n unique_bins = np.unique(bins)\\n for bin in unique_bins:\\n assigned_items_count[bins == bin] = np.count_nonzero(bins[bins == bin])\\n \\n # Calculate the proximity of the bin capacity to the item size\\n proximity = max_capacity - item\\n \\n # Add the proximity, assigned items count, and item size to bin capacity ratio factors to the scores of non-maximum capacity bins\\n scores[bins != max_capacity] = (item / bins[bins != max_capacity]) + (proximity * 0.1) + (assigned_items_count[bins != max_capacity] * 0.01) + (item/bins[bins != max_capacity])\\n \\n # If there are empty bins with maximum capacity, assign them a high score\\n scores[bins == max_capacity] = item / (max_capacity - 1)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign items to bins based on a modified score function that takes into account the proximity of the bin capacity to the item size, as well as an additional parameter called \\\"fill_ratio\\\". The fill_ratio represents the ratio of the item size to the maximum capacity of the bin.\\n\\nThe main steps of the algorithm are as follows:\\n1. Calculate the maximum capacity and its count in the bins.\\n2. Calculate the proximity of the bin capacity to the item size.\\n3. Calculate the fill_ratio of the item size to the maximum capacity.\\n4. Initialize an array of scores with zeros.\\n5. For each bin with non-maximum capacity, calculate the score using the formula: (item / bin_capacity) + (proximity * fill_ratio).\\n6. For each bin with maximum capacity, calculate the score using the formula: item / (bin_capacity - 1).\\n7. Return the scores array.\\n\\nHere is the implementation of the new score function in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n max_capacity_count = np.count_nonzero(bins == max_capacity)\\n proximity = max_capacity - item\\n fill_ratio = item / max_capacity\\n \\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = (item / bins[bins != max_capacity]) + (proximity * fill_ratio)\\n scores[bins == max_capacity] = item / (max_capacity - 1)\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the ratio of item size to bin capacity, and a penalty term based on the number of items already assigned to the bin, in order to minimize the number of used bins.\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n ratios = item / bins.astype(float)\\n penalty = np.log(1 + bins) / (1 + np.count_nonzero(bins != bins.max(), axis=0))\\n scores[bins != bins.max()] = ratios[bins != bins.max()] * penalty[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a modified score function that takes into account the bin capacity, the item size, and the number of items already assigned to a bin. Each bin is assigned the item with the maximum modified score, and empty bins with maximum capacity are not used. The goal is to minimize the number of used bins. \\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n # Calculate the maximum capacity and its count\\n max_capacity = np.max(bins)\\n max_capacity_count = np.count_nonzero(bins == max_capacity)\\n\\n # Calculate the number of items already assigned to each bin\\n assigned_items_count = np.zeros_like(bins)\\n unique_bins = np.unique(bins)\\n for bin in unique_bins:\\n assigned_items_count[bins == bin] = np.count_nonzero(bins[bins == bin])\\n\\n # Calculate the proximity of the bin capacity to the item size\\n proximity = max_capacity - item\\n\\n # Add the proximity and assigned items count factors to the scores of non-maximum capacity bins\\n scores[bins != max_capacity] = (item / bins[bins != max_capacity]) + (proximity * 0.1) + (assigned_items_count[bins != max_capacity] * 0.01)\\n\\n # If there are empty bins with maximum capacity, assign them a high score\\n scores[bins == max_capacity] = item / (max_capacity - 1)\\n\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the sum of the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins + item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Algorithm:\\n1. Initialize an empty array named scores with the same size as bins.\\n2. Calculate the ratio between the item size and each bin capacity.\\n3. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by multiplying the ratio with the bin capacity.\\n c. Round down the result to the nearest integer.\\n d. Assign the calculated score to the corresponding index in the scores array.\\n4. Return the scores array.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(ratio[i] * bins[i])\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the ratio of item size to bin capacity, and a penalty factor based on the bin's remaining capacity to promote filling bins with higher capacity first, in order to minimize the number of used bins.\\n\\nNew Python code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n ratios = item / bins.astype(float)\\n penalties = (bins.max() - bins) / bins.max()\\n scores[bins != bins.max()] = ratios[bins != bins.max()] + penalties[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the square root of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 0.5 # Constant multiplier\\n scores = c * item / (np.sqrt(bins - item)) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the cube root of the bin's current capacity raised to the power of the bin's index plus four, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins raised to the power of three, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.cbrt(bins)**(4*np.arange(len(bins))+4) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the cube root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function:\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated by taking the square root of the bin's current capacity, raised to the power of the bin's index plus one, multiplied by a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = np.sqrt(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\nPython code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, all raised to a power determined by the index of the bin.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus two, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins raised to the power of four, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**4\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins. The penalty term is squared before being added to the score.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (remaining_capacity / total_capacity) ** 2\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, updates the rest capacity of the bin accordingly, and penalizes bins with lower remaining capacity by adding a logarithmic term to the score. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the square root of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 0.5 # Constant multiplier\\n scores = c * item / (np.sqrt(bins - item)) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the cube root of the bin's current capacity raised to the power of the bin's index plus four, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins raised to the power of three, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.cbrt(bins)**(4*np.arange(len(bins))+4) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the cube root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function:\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated by taking the square root of the bin's current capacity, raised to the power of the bin's index plus one, multiplied by a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = np.sqrt(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\nPython code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, all raised to a power determined by the index of the bin.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus two, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins raised to the power of four, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**4\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(3*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, updates the rest capacity of the bin accordingly, and penalizes bins with lower remaining capacity by adding a logarithmic term to the score. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the square root of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 0.5 # Constant multiplier\\n scores = c * item / (np.sqrt(bins - item)) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score that is calculated as the product of the bin's current capacity divided by the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the cube root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function:\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated by taking the logarithm of the bin's current capacity, raised to the power of the bin's index plus one, multiplied by a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\nPython code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, all raised to a power determined by the index of the bin.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings such as a different power value for the natural logarithm and a different coefficient for the penalty term.\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins)) + 2) * penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(3*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, updates the rest capacity of the bin accordingly, and penalizes bins with lower remaining capacity by adding a logarithmic term to the score. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the square root of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 0.5 # Constant multiplier\\n scores = c * item / (np.sqrt(bins - item)) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm calculates the scores based on the remaining capacity of the bins and the total capacity. It penalizes the bins with smaller remaining capacity by applying a logarithmic function and a power function to the original score. The algorithm prioritizes assigning items to bins with larger remaining capacity while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * (1/(remaining_capacity / total_capacity))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the cube root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for the bins based on a modified formula.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (total_capacity / remaining_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n scores = c * item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, all raised to a power determined by the index of the bin.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings such as a different power value for the natural logarithm and a different coefficient for the penalty term.\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins)) + 2) * penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, updates the rest capacity of the bin accordingly, and penalizes bins with lower remaining capacity by adding a logarithmic term to the score. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the square root of the bin's remaining capacity divided by the sum of the square roots of the remaining capacities of all bins.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = np.sqrt(bins) / np.sum(np.sqrt(bins))\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the square root of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 0.5 # Constant multiplier\\n scores = c * item / (np.sqrt(bins - item)) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm calculates the scores based on the remaining capacity of the bins and the total capacity. It penalizes the bins with smaller remaining capacity by applying a logarithmic function and a power function to the original score. The algorithm prioritizes assigning items to bins with larger remaining capacity while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * (1/(remaining_capacity / total_capacity))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the inverse of the item's size divided by the bin's capacity, multiplied by the logarithm of the bin's capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (1 / item) * (1 / bins) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for the bins based on a modified formula.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (total_capacity / remaining_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n scores = c * item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, updates the rest capacity of the bin accordingly, and penalizes bins with lower remaining capacity by adding a logarithmic term to the score. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the square root of the bin's remaining capacity divided by the sum of the square roots of the remaining capacities of all bins.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = np.sqrt(bins) / np.sum(np.sqrt(bins))\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the square root of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 0.5 # Constant multiplier\\n scores = c * item / (np.sqrt(bins - item)) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm calculates the scores based on the remaining capacity of the bins and the total capacity. It penalizes the bins with smaller remaining capacity by applying a logarithmic function and a power function to the original score. The algorithm prioritizes assigning items to bins with larger remaining capacity while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * (1/(remaining_capacity / total_capacity))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the square root of the item's size divided by the bin's capacity, multiplied by the logarithm of the bin's capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (np.sqrt(item) / bins) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the inverse of the difference between the bin capacity and the item size, modified by adding the square of the item size divided by the bin capacity, and multiplying it by the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) * ((item ** 2) / bins) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n scores = c * item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, updates the rest capacity of the bin accordingly, and penalizes bins with lower remaining capacity by adding a logarithmic term to the score. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(5 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity cubed.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**3)\\n scores = bins * ((np.sqrt(bins)/np.sqrt(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the item size and the rest capacities of the feasible bins, using a modified formula, and returns the scores for assignment.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm calculates the scores based on the remaining capacity of the bins and the total capacity. It penalizes the bins with smaller remaining capacity by applying a logarithmic function and a power function to the original score. The algorithm prioritizes assigning items to bins with larger remaining capacity while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * (1/(remaining_capacity / total_capacity))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * (1 / (remaining_capacity**2))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the square root of the item's size divided by the bin's capacity, multiplied by the logarithm of the bin's capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = np.sqrt(item) / bins * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the inverse of the difference between the bin capacity and the item size, modified by adding the square of the item size divided by the bin capacity, and multiplying it by the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) * ((item ** 2) / bins) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n scores = c * item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\nNew algorithm:\\n\\nThe new algorithm score(item, bins) takes in the size of the current item and the rest capacities of feasible bins as input and returns an array of scores for the bins for assignment. The calculation of scores is modified by introducing a new parameter p, which is the power exponent used in the computation.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(5 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity cubed.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**3)\\n scores = bins * ((np.sqrt(bins)/np.sqrt(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the item size and the rest capacities of the feasible bins, using a modified formula, and returns the scores for assignment.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Create a new algorithm that assigns a score to each bin based on their capacity and the size of the current item, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins) + item)) * ((np.log(bins) / np.log(2))**(2*np.arange(len(bins))+3)) * (bins / (bins - item))**2\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: \\n\\nFor each bin in the set of bins,\\n1. Calculate the remaining capacity of the bin after assigning the item to it.\\n2. Calculate the score of the bin using the formula: bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * (1 / (remaining_capacity**2))\\n3. Assign the score to the bin.\\n4. Return the scores for all bins.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * (1 / (remaining_capacity**2))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the square root of the item's size divided by the bin's capacity, multiplied by the logarithm of the bin's capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = np.sqrt(item) / bins * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the inverse of the difference between the bin capacity and the item size, modified by adding the square of the item size divided by the bin capacity, and multiplying it by the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (bins - item)) * ((item ** 2) / bins) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n scores = c * item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\nNew algorithm:\\n\\nThe new algorithm score(item, bins) takes in the size of the current item and the rest capacities of feasible bins as input and returns an array of scores for the bins for assignment. The calculation of scores is modified by introducing a new parameter p, which is the power exponent used in the computation.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(5 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the square root of the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' and a constant exponent 'e' to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n e = 1 # Constant exponent\\n scores = c * item**e / np.sqrt(bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity cubed.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**3)\\n scores = bins * ((np.sqrt(bins)/np.sqrt(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description:\\n\\nThe new algorithm assigns a score to each bin based on a combination of its rest capacity, the size of the current item, and the index of the bin in the array. The score considers the rest capacity of the bin, with a higher score given to bins with larger capacities. Additionally, the score is multiplied by a factor that increases exponentially with the index of the bin, promoting the assignment of items to bins with lower indexes. Finally, the score is squared to ensure the final scores remain positive.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins**2) / (np.sqrt(bins) + item)) * ((np.log(bins) / np.log(2))**(2*np.arange(len(bins))+3)) * (bins / (bins - item))**2\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the item size and the rest capacities of the feasible bins, using a modified formula, and returns the scores for assignment.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / (np.sqrt(bins) + item)) * ((np.log(bins) / np.log(2))**(2*np.arange(len(bins))+3)) * (bins / (bins - item))**2\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: \\n\\nFor each bin in the set of bins,\\n1. Calculate the remaining capacity of the bin after assigning the item to it.\\n2. Calculate the score of the bin using the formula: bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * (1 / (remaining_capacity**2))\\n3. Assign the score to the bin.\\n4. Return the scores for all bins.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * (1 / (remaining_capacity**2))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main algorithm parameters for the new algorithm are the item size ('item') and the rest capacities of feasible bins ('bins'). \\n\\nNew algorithm description: \\n\\nThe new algorithm calculates the score of each bin based on their remaining capacity after assigning the item to it, using a different parameter setting for the score function. The new algorithm uses the formula: bins * ((np.log(bins)/np.log(3))**(3*np.arange(len(bins))+1)) * (1 / (remaining_capacity**3)) to calculate the scores. It then returns the scores for all bins.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(3))**(3*np.arange(len(bins))+1)) * (1 / (remaining_capacity**3))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm step: we calculate the scores for the bins based on the formula: scores = item / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 1)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n scores = c * item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\nNew algorithm:\\n\\nThe new algorithm score(item, bins) takes in the size of the current item and the rest capacities of feasible bins as input and returns an array of scores for the bins for assignment. The calculation of scores is modified by introducing a new parameter p, which is the power exponent used in the computation.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(5 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the square root of the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' and a constant exponent 'e' to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n e = 1 # Constant exponent\\n scores = c * item**e / np.sqrt(bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description:\\n\\nThe new algorithm assigns a score to each bin based on a combination of its rest capacity, the size of the current item, and the index of the bin in the array. The score considers the rest capacity of the bin, with a higher score given to bins with larger capacities. Additionally, the score is multiplied by a factor that increases exponentially with the index of the bin, promoting the assignment of items to bins with lower indexes. Finally, the score is squared to ensure the final scores remain positive.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins**2) / (np.sqrt(bins) + item)) * ((np.log(bins) / np.log(2))**(2*np.arange(len(bins))+3)) * (bins / (bins - item))**2\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the item size and the rest capacities of the feasible bins, using a modified formula, and returns the scores for assignment.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / (np.sqrt(bins) + item)) * ((np.log(bins) / np.log(2))**(2*np.arange(len(bins))+3)) * (bins / (bins - item))**2\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 10)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main algorithm parameters for the new algorithm are the item size ('item') and the rest capacities of feasible bins ('bins'). \\n\\nNew algorithm description: \\n\\nThe new algorithm calculates the score of each bin based on their remaining capacity after assigning the item to it, using a different parameter setting for the score function. The new algorithm uses the formula: bins * ((np.log(bins)/np.log(3))**(3*np.arange(len(bins))+1)) * (1 / (remaining_capacity**3)) to calculate the scores. It then returns the scores for all bins.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(3))**(3*np.arange(len(bins))+1)) * (1 / (remaining_capacity**3))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm step: we calculate the scores for the bins based on the formula: scores = item / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 1)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\nNew algorithm:\\n\\nThe new algorithm score(item, bins) takes in the size of the current item and the rest capacities of feasible bins as input and returns an array of scores for the bins for assignment. The calculation of scores is modified by introducing a new parameter p, which is the power exponent used in the computation.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(5 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin based on their remaining capacity after assigning the item to it, using a different parameter setting for the score function. The new algorithm uses the formula: bins * ((np.log(bins)/np.log(2))**(2+np.arange(len(bins)))) * (1 / (remaining_capacity**2)) to calculate the scores. It then returns the scores for all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(2))**(2+np.arange(len(bins)))) * (1 / (remaining_capacity**2))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the square root of the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' and a constant exponent 'e' to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n e = 1 # Constant exponent\\n scores = c * item**e / np.sqrt(bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account these parameters.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.power(item, 2) / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account both these parameters.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the number of items already assigned to the bin, and a weighting factor determined by the ratio of the rest capacity to the square of the number of items already assigned to the bin. It aims to assign the item to bins that have a larger rest capacity and fewer items already assigned.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()]\\n num_items = bins[bins != bins.max()] - item + 1\\n scores[bins != bins.max()] = (item**2 + rest_capacity**2) / (rest_capacity * num_items**2)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a combination of the bin's current capacity divided by the difference between the bin's capacity and the item size, the number of times the bin has been used, and a penalty term based on the bin's remaining capacity to promote efficient usage of bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + (bins / np.sum(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to a power of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.power((bins - item), 2)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and taking into account the square root of the ratio of the item size to the rest capacity plus 1, in order to minimize the number of used bins.\\n\\nHere's the implementation of the new score function in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()] - item\\n scores[bins != bins.max()] = np.sqrt(item / (rest_capacity + 1) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The scoring method is modified by incorporating both the rest capacity and the number of items of each bin. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1)) + (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1)) * (np.sum(bins != 0) / (np.sum(bins != 0) + 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and also taking into account a penalty factor based on the distance between the current item size and the average bin size, in order to minimize the number of used bins.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n avg_bin_size = np.mean(bins)\\n penalty_factor = np.abs(item - avg_bin_size) / max_capacity\\n \\n scores[bins != max_capacity] = (item / (bins[bins != max_capacity] - item + 1)) * penalty_factor\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. The new algorithm modifies the scoring method by taking into account both the rest capacity of the bin and the number of items already assigned to the bin.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, where the score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity of each bin and the number of items already assigned to the bin. The scoring function is adjusted by incorporating a weighting factor that is determined based on the product of the rest capacity and the number of items already assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 - ((bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))) * (bins[bins != bins.max()] * (bins[bins != bins.max()] != 0))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity of each bin multiplied by a weight, and returns the scores for the bins for assignment.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()] - item\\n scores[bins != bins.max()] = (item / (rest_capacity + 1)) * 10 # Increase weight to promote performance\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the bin with the maximum capacity, and assigns the item to this bin, considering the ratio of item size to the rest capacity of each bin raised to the power of 2, in order to prioritize bins with larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()] - item\\n scores[bins != bins.max()] = (item / (rest_capacity + 1)) ** 2\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity of each bin and the cost of assigning the item to the bin, in order to minimize the number of used bins. The cost of assigning the item to a bin is calculated as the product of the item size and the ratio of the item size to the bin capacity, and a smaller cost indicates a better fit.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n ratios = item / bins.astype(float)\\n costs = item * ratios\\n scores[bins != bins.max()] = costs[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the number of items already assigned to the bin, and a weighting factor determined by the sum of the rest capacity and the number of items already assigned to the bin. It aims to assign the item to bins that have a larger rest capacity and fewer items already assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = ((item**2 + bins[bins != bins.max()]**2) / (bins[bins != bins.max()] - item + 1)) * (1 - ((bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))) * (bins[bins != bins.max()] + (bins[bins != bins.max()] > 0))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\nThe new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity of each bin and the cost of assigning the item to the bin, in order to minimize the number of used bins. The cost of assigning the item to a bin is calculated as the product of the item size and the ratio of the item size to the bin capacity, and a smaller cost indicates a better fit. The new algorithm also takes into account a penalty factor for assigning an item to a bin with high rest capacity, to encourage filling up bins with lower rest capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n ratios = item / bins.astype(float)\\n costs = item * ratios + (1 - ratios)\\n scores[bins != bins.max()] = costs[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the number of items already assigned to the bin, and a weighting factor determined by the product of the rest capacity and the number of items already assigned to the bin. It aims to assign the item to bins that have a larger rest capacity and fewer items already assigned.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = ((item**2 + bins[bins != bins.max()]**2) / (bins[bins != bins.max()] - item + 1)) * (1 - ((bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))) * (bins[bins != bins.max()] * (bins[bins != bins.max()] != 0))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description:\\n\\nThe new algorithm assigns a score to each bin based on a combination of its rest capacity, the size of the current item, and the index of the bin in the array. The score considers the rest capacity of the bin, with a higher score given to bins with larger capacities. Additionally, the score is multiplied by a factor that increases exponentially with the index of the bin, promoting the assignment of items to bins with lower indexes. Finally, the score is squared to ensure the final scores remain positive.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins**2) / (np.sqrt(bins) + item)) * ((np.log(bins) / np.log(2))**(2*np.arange(len(bins))+3)) * (bins / (bins - item))**2\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the item size and the rest capacities of the feasible bins, using a modified formula, and returns the scores for assignment.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / (np.sqrt(bins) + item)) * ((np.log(bins) / np.log(2))**(2*np.arange(len(bins))+3)) * (bins / (bins - item))**2\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 10)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main algorithm parameters for the new algorithm are the item size ('item') and the rest capacities of feasible bins ('bins'). \\n\\nNew algorithm description: \\n\\nThe new algorithm calculates the score of each bin based on their remaining capacity after assigning the item to it, using a different parameter setting for the score function. The new algorithm uses the formula: bins * ((np.log(bins)/np.log(3))**(3*np.arange(len(bins))+1)) * (1 / (remaining_capacity**3)) to calculate the scores. It then returns the scores for all bins.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(3))**(3*np.arange(len(bins))+1)) * (1 / (remaining_capacity**3))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm step: we calculate the scores for the bins based on the formula: scores = item / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 1)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(3 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 3)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus 1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(3 * np.arange(len(bins)) + 4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nIn the new algorithm, the score for each bin will be calculated based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(2 * np.arange(len(bins)) + 2)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\nNew algorithm:\\n\\nThe new algorithm score(item, bins) takes in the size of the current item and the rest capacities of feasible bins as input and returns an array of scores for the bins for assignment. The calculation of scores is modified by introducing a new parameter p, which is the power exponent used in the computation.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n p = 4 # New parameter p\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(p*np.arange(len(bins))+3) * (np.sum(bins) / (bins - item))**2\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm will calculate the score for each bin based on the inverse of the difference between the bin capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of the index of the bin in the list of bins, plus a constant value of 5.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item) * np.log(bins)**(5 * np.arange(len(bins)) + 5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin based on their remaining capacity after assigning the item to it, using a different parameter setting for the score function. The new algorithm uses the formula: bins * ((np.log(bins)/np.log(2))**(2+np.arange(len(bins)))) * (1 / (remaining_capacity**2)) to calculate the scores. It then returns the scores for all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = bins * ((np.log(bins)/np.log(2))**(2+np.arange(len(bins)))) * (1 / (remaining_capacity**2))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the square root of the product of the item size and the inverse of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' and a constant exponent 'e' to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 2.0 # Constant multiplier\\n e = 1 # Constant exponent\\n scores = c * item**e / np.sqrt(bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account these parameters.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.power(item, 2) / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account both these parameters.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account both these parameters. The new score function penalizes bins that have a high number of items already assigned and a low rest capacity.\",\n \"code\": \"def score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n \\n # New modification to the score function\\n scores[bins >= bins.max()/2] = scores[bins >= bins.max()/2] * (1 - (bins[bins >= bins.max()/2] - bins.max()/2) / bins.max())\\n scores[bins < bins.max()/2] = scores[bins < bins.max()/2] * (1 - (bins.max()/2 - bins[bins < bins.max()/2]) / bins.max())\\n \\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the number of items already assigned to the bin, and a weighting factor determined by the ratio of the rest capacity to the cube of the number of items already assigned to the bin. It aims to assign the item to bins that have a larger rest capacity and fewer items already assigned.\\n\\nNew code:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()]\\n num_items = bins[bins != bins.max()] - item + 1\\n scores[bins != bins.max()] = (item**2 + rest_capacity**3) / (rest_capacity * num_items**3)\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the bin with the maximum capacity, and assigns the item to this bin, considering the difference between the item size and the rest capacity of each bin raised to the power of 3, in order to prioritize bins with larger differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()] - item\\n scores[bins != bins.max()] = (item - rest_capacity) ** 3\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the number of items already assigned to the bin, and a weighting factor determined by the ratio of the rest capacity to the square of the number of items already assigned to the bin. It aims to assign the item to bins that have a larger rest capacity and fewer items already assigned.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()]\\n num_items = bins[bins != bins.max()] - item + 1\\n scores[bins != bins.max()] = (item**2 + rest_capacity**2) / (rest_capacity * num_items**2)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a combination of the bin's current capacity divided by the difference between the bin's capacity and the item size, the number of times the bin has been used, and a penalty term based on the bin's remaining capacity to promote efficient usage of bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + (bins / np.sum(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The scoring method takes into account both the rest capacity of the bin, the number of items already assigned to the bin, and a scaling factor.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scaling_factor = 0.5\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))) + scaling_factor * (1 - bins[bins != bins.max()] / (bins[bins != bins.max()] + item))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to a power of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.power((bins - item), 2)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and taking into account the square root of the ratio of the item size to the rest capacity plus 1, in order to minimize the number of used bins.\\n\\nHere's the implementation of the new score function in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()] - item\\n scores[bins != bins.max()] = np.sqrt(item / (rest_capacity + 1) + 1)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used multiplied by a constant factor.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the number of times the bin has been used, the square root of the bin's remaining capacity, and the natural logarithm of the bin's remaining capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + (bins / np.sum(bins)) + np.sqrt(bins) + np.log(bins)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. The new algorithm modifies the scoring method by taking into account both the rest capacity of the bin and the number of items already assigned to the bin.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used. The algorithm then updates the rest capacity of the bin accordingly, until all items are assigned.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity of each bin and the number of items already assigned to the bin. The scoring function is adjusted by incorporating a weighting factor that is determined based on the product of the rest capacity and the number of items already assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 - ((bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))) * (bins[bins != bins.max()] * (bins[bins != bins.max()] != 0))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to a power of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.power((bins - item), 2)) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the bin with the maximum capacity, and assigns the item to this bin, considering the ratio of item size to the rest capacity of each bin raised to the power of 2, in order to prioritize bins with larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()] - item\\n scores[bins != bins.max()] = (item / (rest_capacity + 1)) ** 2\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: \\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's remaining capacity squared, and the natural logarithm of the bin's remaining capacity squared.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + np.sqrt(bins**2) + np.log(bins**2)\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's remaining capacity squared, the natural logarithm of the bin's remaining capacity squared, and the cosine of the bin's remaining capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + np.sqrt(bins**2) + np.log(bins**2) + np.cos(bins)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The scoring method takes into account both the rest capacity of the bin, the number of items already assigned to the bin, a scaling factor, and a penalty factor.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scaling_factor = 0.5\\n penalty_factor = 0.2\\n \\n bins_with_space = bins[bins != bins.max()]\\n num_items_assigned = item - bins_with_space + 1\\n \\n scores[bins != bins.max()] = (item / num_items_assigned * (1 - (bins_with_space != 0) / (bins_with_space + 1))) + scaling_factor * (1 - bins_with_space / (bins_with_space + item)) - penalty_factor * num_items_assigned\\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's remaining capacity squared, and the natural logarithm of the bin's remaining capacity squared, with different weightings for each component.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + 2*np.sqrt(bins**2) + 0.5*np.log(bins**2)\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the square root of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = remaining_capacity / total_capacity\\n scores = np.log(bins / (bins - item)) * np.sqrt(np.power(bins, np.arange(len(bins)))) * penalty\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account these parameters.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.power(item, 2) / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account both these parameters.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account both these parameters. The new score function penalizes bins that have a high number of items already assigned and a low rest capacity.\",\n \"code\": \"def score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 - (bins[bins != bins.max()] != 0) / (bins[bins != bins.max()] + 1))\\n scores[bins != bins.max()] = scores[bins != bins.max()] / np.power(2, bins[bins != bins.max()] - item)\\n \\n # New modification to the score function\\n scores[bins >= bins.max()/2] = scores[bins >= bins.max()/2] * (1 - (bins[bins >= bins.max()/2] - bins.max()/2) / bins.max())\\n scores[bins < bins.max()/2] = scores[bins < bins.max()/2] * (1 - (bins.max()/2 - bins[bins < bins.max()/2]) / bins.max())\\n \\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The score function is modified to take into account these parameters as well as the maximum capacity of the bins.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n mask = bins != max_capacity\\n rest_capacity = bins[mask]\\n num_items = max_capacity - rest_capacity + 1\\n \\n scores[mask] = np.power(item, 2) / num_items * (1 - (rest_capacity != 0) / (rest_capacity + 1))\\n scores[mask] = scores[mask] / np.power(2, rest_capacity - item)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, the number of items already assigned to the bin, and the maximum capacity of the bins, in order to minimize the number of used bins. The score function is modified to take into account these parameters as well as the size of the current item and the rest capacities of feasible bins.\\n\\nNew algorithm implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n \\n mask = bins != max_capacity\\n rest_capacity = bins[mask]\\n num_items = max_capacity - rest_capacity + 1\\n \\n scores[mask] = (np.power(num_items, 2) / np.power(item, 2)) * (1 - (rest_capacity != 0) / (rest_capacity + 1))\\n scores[mask] = scores[mask] / np.power(2, rest_capacity - item)\\n \\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used multiplied by a constant factor.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins)) * 0.25\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the bin with the maximum capacity, and assigns the item to this bin, considering the difference between the item size and the rest capacity of each bin raised to the power of 3, in order to prioritize bins with larger differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rest_capacity = bins[bins != bins.max()] - item\\n scores[bins != bins.max()] = (item - rest_capacity) ** 3\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to a power of the difference between the bin's capacity and the item size, plus the number of times the bin has been used multiplied by a constant factor.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.power((bins - item), 2)) + np.arange(len(bins)) * 0.5\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity of each bin and the number of items already assigned to the bin. The scoring function is adjusted by incorporating a weighting factor that is determined based on the product of the rest capacity and the number of items already assigned to the bin. In addition, a penalty term is introduced to discourage assigning an item to a nearly full bin.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_capacity = bins.max()\\n num_items_assigned = bins[bins != max_bin_capacity] \\n\\n scores = np.zeros_like(bins)\\n mask = bins != max_bin_capacity\\n\\n capacity_penalty = 1 / (bins[mask] - item + 1) * (1 - (num_items_assigned / (bins[mask] + 1)))\\n items_penalty = bins[mask] * (bins[mask] != 0)\\n\\n scores[mask] = (item / (bins[mask] - item + 1)) * (1 - ((bins[mask] != 0) / (bins[mask] + 1))) * capacity_penalty * items_penalty\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a combination of the bin's current capacity divided by the difference between the bin's capacity and the item size, the number of times the bin has been used, and a penalty term based on the bin's remaining capacity to promote efficient usage of bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + (bins / np.sum(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used multiplied by a constant factor.\\n\\nNew algorithm implementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\n# Main algorithm parameters\\nconstant_factor = 0.5\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins)) * constant_factor\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to a power of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.power((bins - item), 2)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used multiplied by a constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(bins - item)) + np.arange(len(bins)) * 0.25\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The adjusted algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nHere is the Python implementation of the score function for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins. The penalty term is squared before being added to the score.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (remaining_capacity / total_capacity) ** 2\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the cube root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.cbrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\nCode implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score for each bin is calculated as the square root of the bin's current capacity raised to the power of the bin's index, divided by the difference between the bin's capacity and the item size, multiplied by a penalty term based on the inverse of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(bins) ** np.arange(len(bins))) / (bins - item) * (1 / remaining_capacity)\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by a weight factor based on a new parameter 'alpha', divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n alpha = 2 # New parameter 'alpha' for adjusting the weight factor\\n scores = ((alpha * bins * item) / (bins - item)) * np.sqrt(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity multiplied by the item size, divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nHere's the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins - item)) * np.sqrt(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"\\n This algorithm calculates the score for each bin based on the following steps:\\n - Calculate the remaining capacity of each bin after assigning the item.\\n - Calculate the scores as the logarithm of the bin's current capacity raised to the power of the bin's index, divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by a penalty term based on the inverse of the bin's remaining capacity.\\n \\\"\\\"\\\"\\n remaining_capacity = bins - item\\n scores = (np.log(bins) ** np.arange(len(bins))) / (np.log(bins - item)) * (1 / remaining_capacity)\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the cube root of the bin's remaining capacity cubed, and the base-10 logarithm of the bin's remaining capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + np.cbrt(bins**3) + np.log10(bins**2)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The scoring method takes into account both the rest capacity of the bin, the number of items already assigned to the bin, a scaling factor, and a penalty factor. The new algorithm will tweak the parameter settings in the scoring function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scaling_factor = 0.8 # Changed scaling factor to 0.8\\n penalty_factor = 0.1 # Changed penalty factor to 0.1\\n \\n bins_with_space = bins[bins != bins.max()]\\n num_items_assigned = item - bins_with_space + 1\\n \\n scores[bins != bins.max()] = (item / num_items_assigned * (1 - (bins_with_space != 0) / (bins_with_space + 1))) + scaling_factor * (1 - bins_with_space / (bins_with_space + item)) - penalty_factor * num_items_assigned\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the number of items already assigned to the bin, in order to minimize the number of used bins. The scoring method takes into account both the rest capacity of the bin, the number of items already assigned to the bin, a scaling factor, and a penalty factor.\\n\\n\",\n \"code\": \"def score(item, bins):\\n scores = np.zeros_like(bins)\\n scaling_factor = 0.7\\n penalty_factor = 0.1\\n \\n bins_with_space = bins[bins != bins.max()]\\n num_items_assigned = item - bins_with_space + 1\\n \\n scores[bins != bins.max()] = (item / num_items_assigned * (1 - (bins_with_space != 0) / (bins_with_space + 1))) + scaling_factor * (1 - bins_with_space / (bins_with_space + item)) - penalty_factor * num_items_assigned\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: My new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, the square root of the bin's remaining capacity squared, and the natural logarithm of the bin's remaining capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.exp(bins - item)) + np.arange(len(bins)) + np.sqrt(bins**2) + np.log(bins)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's remaining capacity squared, the natural logarithm of the bin's remaining capacity squared, and the sine of the bin's remaining capacity multiplied by the cosine of the bin's remaining capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + np.sqrt(bins**2) + np.log(bins**2) + np.sin(bins) * np.cos(bins)\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: My new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's remaining capacity squared, and the natural logarithm of the bin's remaining capacity squared.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + np.sqrt(bins**2) + np.log(bins**2)\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin will be calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's remaining capacity squared, the natural logarithm of the bin's remaining capacity squared, and the cosine of the bin's remaining capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) + np.sqrt(bins**2) + np.log(bins**2) + np.cos(bins)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse logarithm of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / np.log(remaining_capacity) / total_capacity\\n scores = (bins / (bins + item)) * np.sqrt(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the difference between the bin's current capacity and the item's size, multiplied by the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins - item) * np.sqrt(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of a weighted ratio of the bin's current capacity to the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins / (bins - item))**(1/3)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The adjusted algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nHere is the Python implementation of the score function for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The modified algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the natural logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / np.sqrt(bins - item)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins. The penalty term is squared before being added to the score.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (remaining_capacity / total_capacity) ** 2\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the cube root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.cbrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\nCode implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.sqrt(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins to the power of 4, with different values for the penalty term and the exponent in the square root function.\\n\\nHere's the implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score for each bin is calculated as the square root of the bin's current capacity raised to the power of the bin's index, divided by the difference between the bin's capacity and the item size, multiplied by a penalty term based on the inverse of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(bins) ** np.arange(len(bins))) / (bins - item) * (1 / remaining_capacity)\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins to the power of 4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**4\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by a weight factor based on a new parameter 'alpha', divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n alpha = 2 # New parameter 'alpha' for adjusting the weight factor\\n scores = ((alpha * bins * item) / (bins - item)) * np.sqrt(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, the square root of the bin's capacity, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * np.sqrt(bins) * penalty\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of a weighted ratio of the bin's current capacity to the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins / (bins - item))**(1/3)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the cube root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function:\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.sqrt(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, where the score for each bin is calculated as the ratio between the item's size and the difference between the bin's current capacity and the item's size, multiplied by the square root of the bin's current capacity raised to the power of the bin's index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2*np.arange(len(bins))+1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The modified algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the natural logarithm of the bin's current capacity raised to the power of three times the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / np.sqrt(bins - item)) * np.log(bins) ** (3 * np.arange(len(bins)) + 1) * penalty\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, all raised to a power determined by the index of the bin.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of a weighted ratio of the bin's current capacity to the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's current capacity raised to the power of two times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item))**(1/2) * np.log(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins. The penalty term is squared before being added to the score.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (remaining_capacity / total_capacity) ** 2\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, divided by the sum of the bin's capacity and the item size, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * np.log2(bins) ** np.arange(len(bins))) / (bins + item)) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the cube root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.cbrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of a weighted ratio of the bin's current capacity to the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins / (bins - item))**(1/3)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the cube root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function:\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.sqrt(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The modified algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the natural logarithm of the bin's current capacity raised to the power of three times the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / np.sqrt(bins - item)) * np.log(bins) ** (3 * np.arange(len(bins)) + 1) * penalty\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, all raised to a power determined by the index of the bin.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus two, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins raised to the power of four, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**4\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins. The penalty term is squared before being added to the score.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (remaining_capacity / total_capacity) ** 2\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / np.sqrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different coefficient values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (2 * bins / np.sqrt(bins - item)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"1. My new algorithm assigns an item to the bin with the maximum score by calculating the score for each bin based on the bin's capacity, the item size, and a penalty term.\\n\\nHere is the updated code for the score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(3*np.arange(len(bins))+3) * penalty\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * ((np.log(bins)/np.log(2))**(2*np.arange(len(bins))+1)) * penalty\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the square root of the difference between the bin capacity and the item size, with an additional term that increases exponentially with the bin index. The formula can be modified by adding a constant multiplier 'c' to the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n c = 0.5 # Constant multiplier\\n scores = c * item / (np.sqrt(bins - item)) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of a weighted ratio of the bin's current capacity to the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins / (bins - item))**(1/3)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the cube root of the sum of the bin's capacity and the item size, the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / np.cbrt(bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function:\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / (bins + item)) * np.log(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)\\n scores = bins * np.sqrt(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = item / (bins - item) * np.sqrt(bins)**(2 * np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity raised to the power of three times the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.log(bins) ** (3 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The modified algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the natural logarithm of the bin's current capacity raised to the power of three times the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / np.sqrt(bins - item)) * np.log(bins) ** (3 * np.arange(len(bins)) + 1) * penalty\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, all raised to a power determined by the index of the bin.\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) + np.sqrt(bins) ** (2 * np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus two, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins raised to the power of four, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**4\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the bin's current capacity raised to the power of the bin's index, and a penalty term based on the bin's remaining capacity divided by the total remaining capacity of all bins. The penalty term is squared before being added to the score.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = (remaining_capacity / total_capacity) ** 2\\n scores = (bins / (bins - item)) * np.power(bins, np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, updates the rest capacity of the bin accordingly, and penalizes bins with lower remaining capacity by adding a logarithmic term to the score. The score for each bin is calculated as the ratio of the bin's current capacity to the item's size, multiplied by the logarithm of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity squared, with different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity**2)\\n scores = (bins / item) * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of twice the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = (bins / (bins - item)) * np.sqrt(bins) ** (2 * np.arange(len(bins))) * penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nAssign an item to the bin with the maximum score, where the score for each bin is calculated as the product of the bin's current capacity, the natural logarithm of the bin's current capacity raised to the power of twice the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins, with different parameter settings for the penalty term.\\n\\nUpdated code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = bins * np.log(bins)**(2*np.arange(len(bins))+1) * penalty\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins cubed, with different parameter settings.\\n\\n\",\n \"code\": \"def score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**3\\n scores = (bins / (bins + item)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity multiplied by the item size, divided by the sum of the bin's capacity and the item size, the logarithm base 2 of the bin's current capacity raised to the power of the bin's index, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / remaining_capacity / total_capacity\\n scores = ((bins * item) / (bins + item)) * np.log2(bins) ** np.arange(len(bins)) * penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity divided by the sum of the bin's capacity and the item size, the square root of the bin's current capacity raised to the power of the bin's index plus one, and a penalty term based on the inverse of the bin's remaining capacity divided by the total remaining capacity of all bins squared, with different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n remaining_capacity = bins - item\\n penalty = 1 / (remaining_capacity / total_capacity)**2\\n scores = (bins / ((bins + item)**2)) * np.sqrt(bins)**(2*np.arange(len(bins))+2) * penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 1.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 1.5\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log1p(bins - item) + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 1.2\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.8.\\n\\nNew Algorithm Implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 0.8\\n return scores\",\n \"objective\": 0.03642,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nAssign an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, plus the number of times the bin has been used, multiplied by a constant factor of 2.0.\\n\\nNew code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** 1.2 + np.arange(len(bins)) * 2.0\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square root of the bin's current capacity, plus the number of times the bin has been used, multiplied by a constant factor. The constant factor is set to 3.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.sqrt(bins) + np.arange(len(bins)) * 3\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor. The constant factor is set to 1.5.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins)) * 1.5\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + item / bins\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor.\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) * 0.5\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the logarithm base 2 of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.5.\\n\\nNew Algorithm Implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log2(bins - item) + 1) + np.arange(len(bins)) * 0.5\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.7.\\n\\nNew Algorithm Implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins)) * 0.7\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins)) * 0.5\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square root of the bin's current capacity, plus the number of times the bin has been used, multiplied by a constant factor. The constant factor is set to 2.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.sqrt(bins) + np.arange(len(bins)) * 2\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (with different parameter settings):\\n\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used, multiplied by 3.\\n\\nNew code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) + np.sqrt(np.arange(len(bins))) * 3\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores. The score is calculated using a formula that takes into account the difference in capacity between each bin and the maximum capacity, as well as the size of the item. The formula is as follows: scores = (bins.max() - bins) - item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) - item\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score calculated using a different parameter setting, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n # New parameter setting\\n scores[bins != max_capacity] = (item**2) / bins[bins != max_capacity]\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 2.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) + np.arange(len(bins)) * 2\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new set of parameters: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.log(bins) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: \\nThe new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the item size, plus the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the cube root of the logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(item)) + (bins / np.cbrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cube root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere's the updated implementation of the score function:\\n\\n```\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the natural logarithm of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its natural logarithm, plus the sine of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.log(item) + np.sin(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the logarithm of the item size, plus the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2.0\\n scores = (bins / np.log(item)) + (bins / np.sqrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the natural logarithm of the bin's current capacity divided by the square root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.cbrt(bins) * item / (item**(1/3)) + np.log(bins) / math.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 10.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+10))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square of the item size, plus the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the natural logarithm of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 3.0\\n scores = (bins / (item * item)) + (bins / np.cbrt(bins - item)) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.log(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new set of parameters: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.log(bins) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cube root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere's the updated implementation of the score function:\\n\\n```\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the natural logarithm of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its natural logarithm, plus the sine of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.log(item) + np.sin(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm of the bin's current capacity divided by the square root of the item size, minus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.cbrt(bins) * item / (item**(1/3)) + np.log(bins) / np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 10.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+10))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square of the item size, plus the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the natural logarithm of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 3.0\\n scores = (bins / (item * item)) + (bins / np.cbrt(bins - item)) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.log(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Modified New Algorithm\\n\\nIn the modified new algorithm, the score for each bin will be calculated based on the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its square root, plus the cube root of the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.7\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.sqrt(item)) + (np.cbrt(np.log(bins))) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new set of parameters: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.log(bins) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm base 2 of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log2(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere's the updated implementation of the score function:\\n\\n```\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin by taking into account the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size divided by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its natural logarithm, plus the sine of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.log(item) + np.sin(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm of the bin's current capacity divided by the square root of the item size, minus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.cbrt(bins) * item / (item**(1/3)) + np.log(bins) / np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 10.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+10))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Modified New Algorithm\\n\\nIn the modified new algorithm, the score for each bin will be calculated based on the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its square root, plus the cube root of the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.7\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.sqrt(item)) + (np.cbrt(np.log(bins))) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new set of parameters: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.log(bins) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm base 2 of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log2(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere's the updated implementation of the score function:\\n\\n```\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin by taking into account the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size divided by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm of the bin's current capacity divided by the square root of the item size, minus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.cbrt(bins) * item / (item**(1/3)) + np.log(bins) / np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 10.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+10))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Modified New Algorithm\\n\\nIn the modified new algorithm, the score for each bin will be calculated based on the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its square root, plus the cube root of the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.7\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.sqrt(item)) + (np.cbrt(np.log(bins))) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new set of parameters: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.log(bins) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm base 2 of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log2(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere's the updated implementation of the score function:\\n\\n```\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin by taking into account the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size divided by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size.\\n\\nPython Code:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm of the bin's current capacity divided by the square root of the item size, minus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.cbrt(bins) * item / (item**(1/3)) + np.log(bins) / np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. New algorithm description: \\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\\n\\n2. Implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 10.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+10))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Modified New Algorithm\\n\\nIn the modified new algorithm, the score for each bin will be calculated based on the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its square root, plus the cube root of the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.7\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.sqrt(item)) + (np.cbrt(np.log(bins))) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new set of parameters: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.log(bins) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm base 2 of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log2(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin by taking into account the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size divided by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.cbrt(np.abs(bins - item)))) + (np.cbrt(item) * np.log1p(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size.\\n\\nPython Code:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2, with a different parameter setting for the score function provided.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item+1) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. New algorithm description: \\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\\n\\n2. Implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.exp(np.tan(item+1) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the square root of the item size divided by the natural logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nImplementation:\\n``` \",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.sqrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm base 2 of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log2(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin by taking into account the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size divided by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, minus the number of times the bin has been used, plus the square root of four times the item size.\\n\\nPython Code:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) - np.arange(len(bins)) + np.sqrt(4*item)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.cbrt(np.abs(bins - item)))) + (np.cbrt(item) * np.log1p(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size.\\n\\nPython Code:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of twice the item size.\\n\\nPython Code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.sqrt(2*item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. New algorithm description: \\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\\n\\n2. Implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.exp(np.tan(item+1) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the square root of the item size divided by the natural logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nImplementation:\\n``` \",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.sqrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm base 2 of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log2(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin by taking into account the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size divided by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a modified parameter setting: the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.cbrt(np.abs(bins - item)))) + (np.cbrt(item) * np.log1p(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, minus the square of the item size.\\n\\nPython Code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) - (item**2)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of twice the item size.\\n\\nPython Code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.sqrt(2*item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"1. New algorithm description: \\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\\n\\n2. Implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.exp(np.tan(item+1) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the square root of the item size divided by the natural logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nImplementation:\\n``` \",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.sqrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking into account the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its cube root, plus the logarithm base 2 of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.cbrt(item) + np.log2(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the cube of the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, minus the square root of twice the item size.\\n\\nPython Code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (np.abs(bins - item)**3)) + (bins / np.log(item+1)) + np.arange(len(bins)) - np.sqrt(2*item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a modified parameter setting: the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.cbrt(np.abs(bins - item)))) + (np.cbrt(item) * np.log1p(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, minus the square of the item size.\\n\\nPython Code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) - (item**2)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of twice the item size.\\n\\nPython Code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.sqrt(2*item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + bins / np.log(item) + np.arange(len(bins)) + np.sqrt(item) / (np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the natural logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, multiplied by the square root of the item size, plus the base 2 logarithm of the bin's capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) * np.sqrt(item) + (np.log2(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.exp(np.tan(item+1) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the square root of the item size divided by the natural logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nImplementation:\\n``` \",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.sqrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the square of the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.square(np.abs(bins - item)) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its square root, plus the square root of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.sqrt(item) + np.sqrt(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the cube of the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, minus the square root of twice the item size.\\n\\nPython Code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (np.abs(bins - item)**3)) + (bins / np.log(item+1)) + np.arange(len(bins)) - np.sqrt(2*item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a modified parameter setting: the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.cbrt(np.abs(bins - item)))) + (np.cbrt(item) * np.log1p(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, minus the square of the item size.\\n\\nPython Code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) - (item**2)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of twice the item size.\\n\\nPython Code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.sqrt(2*item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + bins / np.log(item) + np.arange(len(bins)) + np.sqrt(item) / (np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the natural logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, multiplied by the square root of the item size, plus the base 2 logarithm of the bin's capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) * np.sqrt(item) + (np.log2(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.exp(np.tan(item+1) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the log of the sum of the item size and the bin's capacity, divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item + bins)) / np.sqrt(np.abs(bins - item)) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02737,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 0.5\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 1.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 1.5\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.7.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 0.7\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 1.2\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.8.\\n\\nNew Algorithm Implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 0.8\\n return scores\",\n \"objective\": 0.03642,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the highest score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, minus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log1p(bins - item) - np.sqrt(np.arange(len(bins)))**2)\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, minus the number of times the bin has been used, multiplied by a constant factor of 2.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** 1.2 - np.arange(len(bins)) * 2\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = bins / (bins - item)**(2/3) + np.arange(len(bins)) * 1.5\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nAssign an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, plus the number of times the bin has been used, multiplied by a constant factor of 2.5.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** 1.2 + np.arange(len(bins)) * 2.5\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"def score(item, bins):\\n scores = (bins / (bins - item)) ** 1.5 + np.arange(len(bins)) * 3.0\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + item / bins\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the natural log of the bin's current capacity, plus the number of times the bin has been used, multiplied by a constant factor of 3.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) + np.log(bins) + np.arange(len(bins)) * 3\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins)) * 0.6\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor.\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) * 0.5\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the square root of the item size divided by the natural logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nImplementation:\\n``` \",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.sqrt(item) / np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the square of the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, plus the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.square(np.abs(bins - item)) + np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its square root, plus the square root of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.sqrt(item) + np.sqrt(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: Assign an item to the bin with the maximum score, calculated as the sum of the square root of the bin's current capacity divided by the square root of the item multiplied by the item size, and the cube root of the bin's current capacity divided by the bin's capacity minus the item size, minus the number of times the bin has been used. Here, the logarithm and absolute difference components from the original algorithm are not considered in the scoring function.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.sqrt(item) * item + np.cbrt(bins) / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a modified parameter setting: the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the natural logarithm of the bin's current capacity multiplied by the item size, minus twice the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(bins - item)) + (np.log(bins) * item) - 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the cube root of the bin's current capacity divided by the squared difference between the bin's capacity and the item size, plus the base 10 logarithm of the bin's current capacity multiplied by the item size, minus the number of times the bin has been used.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / (bins - item)**2) + (np.log10(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (bins / np.sqrt(np.cbrt(np.abs(bins - item)))) + (np.cbrt(item) * np.log1p(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, minus the square of the item size.\\n\\nPython Code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) - (item**2)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of twice the item size.\\n\\nPython Code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.sqrt(2*item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + bins / np.log(item) + np.arange(len(bins)) + np.sqrt(item) / (np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to the bin with the highest score. The score is calculated using a new parameter setting: the natural logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, multiplied by the square root of the item size, plus the base 2 logarithm of the bin's capacity multiplied by the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.abs(bins - item)) * np.sqrt(item) + (np.log2(bins) * item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + np.exp(np.tan(item+1) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - np.cbrt(item) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description:\\nAssign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the natural logarithm of the item size divided by its square root, plus the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity divided by the natural logarithm of the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins * (np.log(item) / np.sqrt(item)) + bins / (bins - item) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins) / np.log(item))\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the square root of the item size multiplied by the cube root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.sqrt(item) * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its cube root, plus the square root of the bin's current capacity divided by the item size, minus the square root of the bin's current capacity multiplied by the item size, and finally, plus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + bins * np.log(item) / np.cbrt(item) + np.sqrt(bins / item) - np.sqrt(bins * item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity, and divided by the item size plus 1.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins)) / (item + 1)\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nAssign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity divided by the logarithm of the item size, plus the bin's current capacity divided by the square root of the item size, plus the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins / np.log(item) + bins / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nAssign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity divided by the logarithm of the item size, plus the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins / np.log(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02234,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the sine of the difference between the item size and the bin's capacity, divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n c = np.cos(bins)\\n s = np.sin(item - bins)\\n scores = bins * s / np.sqrt(np.abs(bins - item)) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02254,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the square root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.sqrt(item) * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the log of the sum of the item size and the bin's capacity, divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item + bins)) / np.sqrt(np.abs(bins - item)) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02737,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins / np.log(item) + np.arange(len(bins)) - np.cbrt(item) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the score for each bin as the sum of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the ratio between the square root of the bin's capacity and the logarithm of the item, plus the number of times the bin has been used, multiplied by the square root of the item size and the cube root of the bin's capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) + ((np.sqrt(bins) / np.log(item)) + np.arange(len(bins))) + (np.sqrt(item) * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 0.5\\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 1.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 1.5\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant factor of 0.7.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + np.arange(len(bins)) * 0.7\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.'\\n\\nNew code:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - np.cbrt(item) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by the square root, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins * np.log(item) / np.sqrt(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the product of the absolute difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the square root of the item size, minus the number of times the bin has been used divided by the cube root of the item size, multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item) * bins) + bins * np.log(item) - np.arange(len(bins)) / (item ** (1/3)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size, minus the number of times the bin has been used divided by the cube root of the item size, multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins * np.log(item) - np.arange(len(bins)) / (item ** (1/3)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is to modify the original score function by adding a penalty term that penalizes bins with capacities close to the item size, aiming to encourage the assignment of items to bins with larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n penalty = np.exp(-abs(bins - item) / (item/2))\\n scores = scores - penalty\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the bin's current capacity divided by twice the absolute difference between the bin's capacity and the item size, plus the number of times the bin has been used, minus the square root of the item size multiplied by the cube root of the bin's current capacity divided by the natural logarithm of the item size.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins * (np.log(item) / (item ** (1/3))) + bins / (2 * (bins - item)) + np.arange(len(bins)) - (np.sqrt(item) * (bins ** (1/3)) / np.log(item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n penalty = np.exp(-abs(bins - item) / (item*2))\\n scores = scores - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the number of times the bin has been used.'\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.sqrt(item)) + (np.sqrt(item) * np.log(bins))\\n scores -= np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the square root of the item size multiplied by the square root of the bin's current capacity, and multiplied by the square root of the item size divided by the bin's capacity.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.sqrt(item) * np.sqrt(bins)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description:\\nAssign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the natural logarithm of the item size divided by its square root, plus the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity divided by the natural logarithm of the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins * (np.log(item) / np.sqrt(item)) + bins / (bins - item) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins) / np.log(item))\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the square root of the item size multiplied by the cube root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.sqrt(item) * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its cube root, plus the square root of the bin's current capacity divided by the item size, minus the square root of the bin's current capacity multiplied by the item size, and finally, plus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + bins * np.log(item) / np.cbrt(item) + np.sqrt(bins / item) - np.sqrt(bins * item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity, and divided by the item size plus 1.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins)) / (item + 1)\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the natural logarithm of the item size, plus the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity, and divided by the item size plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(item))) + (bins / np.sqrt(np.abs(bins - item))) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins)) / (item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nAssign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's current capacity divided by the logarithm of the item size, plus the bin's current capacity divided by the square root of the item size, plus the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins / np.log(item) + bins / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity, and divided by the item size plus 1.\\n\\nNew Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by twice the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the logarithm of the item size, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity, and divided by 2 times the item size plus 1.\\n\\nNew Code:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (2 * np.sqrt(np.abs(bins - item)))) + (bins / np.log(item)) + np.arange(len(bins)) - (np.cbrt(item) * np.sqrt(bins)) / (2 * item + 1)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item)) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.'\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.'\\n\\nNew code:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its cube root, plus the square root of the product of the item size and the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins * np.log(item) / np.cbrt(item)) + (np.sqrt(item * np.log(bins))) - (np.square(np.arange(len(bins))) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.'\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its square root, plus the square root of the natural logarithm of the item size multiplied by the bin's current capacity, minus the number of times the bin has been used.\\n\\nCode:\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.sqrt(item) + np.sqrt(np.log(item)) * np.sqrt(bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - np.cbrt(item) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description:\\n\\nIn the new algorithm, the score function calculates the score for each bin based on the following formula: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size divided by its square root, plus the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by the square root, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins * np.log(item) / np.sqrt(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its square root, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.'\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.sqrt(item)) + (np.sqrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item)) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the natural logarithm of the item size divided by its square root, plus the bin's current capacity divided by 2 times the absolute difference between the bin's capacity and the item size, plus the number of times the bin has been used, minus the square root of the item size multiplied by the square root of the bin's current capacity divided by the natural logarithm of the item size.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins * (np.log(item) / (np.sqrt(item))) + bins / (2 * (bins - item)) + np.arange(len(bins)) - (np.sqrt(item) * (np.sqrt(bins)) / np.log(item))\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the product of the absolute difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the square root of the item size, minus the number of times the bin has been used divided by the cube root of the item size, multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item) * bins) + bins * np.log(item) - np.arange(len(bins)) / (item ** (1/3)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size, minus the number of times the bin has been used divided by the cube root of the item size, multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins * np.log(item) - np.arange(len(bins)) / (item ** (1/3)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is to modify the original score function by adding a penalty term that penalizes bins with capacities close to the item size, aiming to encourage the assignment of items to bins with larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n penalty = np.exp(-abs(bins - item) / (item/2))\\n scores = scores - penalty\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the original score function by introducing a different scaling factor and penalty term. \\n\\nAlgorithm steps: \\n1) Calculate the base scores using the original score function with the modified scaling factor and penalty term. \\n2) Subtract the penalty term from the base scores to obtain the final scores for the bins. \\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 0.5 # Different scaling factor\\n penalty = np.exp(-abs(bins - item) / (item/4)) # Different penalty term\\n \\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n scores = scores - penalty\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the original score function by introducing a scaling factor that adjusts the penalty term to be more influential based on the difference between the bin capacity and the item size. The main steps are: 1) Calculate the base scores using the original score function, 2) Calculate the penalty term using the modified scaling factor, 3) Subtract the penalty term from the base scores to obtain the final scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 0.8\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n penalty = np.exp(-abs(bins - item) / (item/2)) * scaling_factor\\n scores = scores - penalty\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the bin's current capacity divided by twice the absolute difference between the bin's capacity and the item size, plus the number of times the bin has been used, minus the square root of the item size multiplied by the cube root of the bin's current capacity divided by the natural logarithm of the item size.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins * (np.log(item) / (item ** (1/3))) + bins / (2 * (bins - item)) + np.arange(len(bins)) - (np.sqrt(item) * (bins ** (1/3)) / np.log(item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm is to modify the original score function by introducing a scaling factor that adjusts the penalty term to be more influential based on the difference between the bin capacity and the item size. The main steps are: 1) Calculate the base scores using the original score function, 2) Calculate the penalty term using the modified scaling factor, 3) Subtract the penalty term from the base scores to obtain the final scores for the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 0.5\\n scores = (np.sqrt(bins) / np.sqrt(np.abs(bins - item))) + bins * np.sqrt(item) / item + np.arange(len(bins))\\n penalty = np.exp(-abs(bins - item) / (item/2)) * scaling_factor\\n scores = scores - penalty\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: Assign an item to the bin with the maximum score, calculated as the bin's current capacity multiplied by the natural logarithm of the item size divided by its cube root, plus the bin's current capacity divided by four times the absolute difference between the bin's capacity and the item size, plus the number of times the bin has been used, minus the square root of the item size divided by the cube root of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins * (np.log(item) / (item ** (1/3))) + bins / (4 * np.abs(bins - item)) + np.arange(len(bins)) - (np.sqrt(item) / (bins ** (1/3)))\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item)) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.'\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the item size, plus the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size divided by its square root, plus the product of the square root of the bin's current capacity and the logarithm of the item size, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity, with the logarithm base set to 10, and the item size subtracted by the bin size as the exponent in the logarithm function.'\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item)) + (bins / np.sqrt(bins - item) * (np.log10(item) / np.sqrt(item))) + (np.sqrt(bins) * np.log10(item)) - (np.square(np.arange(len(bins))) / np.sqrt(bins) - np.log10(bins - item))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: \\nThe new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the item size, plus the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the cube root of the logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(item)) + (bins / np.cbrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item**2) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.'\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its square root, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nNew code:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.sqrt(item))) + (np.sqrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity. This algorithm also takes into account an additional parameter 'm', which multiplies the cube root of the bin's current capacity and is subtracted from the score.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n m = 0.1\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins) - (m * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"[new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.]\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its square root, plus the square root of the natural logarithm of the item size multiplied by the bin's current capacity, minus the number of times the bin has been used.\\n\\nCode:\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.sqrt(item) + np.sqrt(np.log(item)) * np.sqrt(bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - np.cbrt(item) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the item size, plus the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size divided by its square root, plus the product of the square root of the bin's current capacity and the logarithm of the item size, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.'\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item)) + (bins / np.sqrt(bins - item) * (np.log(item) / np.sqrt(item))) + (np.sqrt(bins) * np.log(item)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its square root, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the natural logarithm of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.sqrt(item)) + (np.sqrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.log(bins))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description:\\n\\nIn the new algorithm, the score function calculates the score for each bin based on the following formula: the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size divided by its square root, plus the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by the square root, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins * np.log(item) / np.sqrt(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\\"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the item size, plus the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size divided by its square root, plus the product of the cube root of the bin's current capacity and the logarithm of the item size, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\\"\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(item)) + (bins / np.sqrt(bins - item) * (np.log(item) / np.sqrt(item))) + (np.cbrt(bins) * np.log(item)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its square root, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the natural logarithm of the bin's current capacity, and finally divided by the square root of the natural logarithm of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins * np.log(item) / np.sqrt(item)) + (np.sqrt(item) * np.log(bins)) - ((np.arange(len(bins)) ** 2) / np.log(bins)) / np.sqrt(np.log(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\nThe new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item size, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity raised to the power of 0.4.\\n\\nPython Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * np.power(bins, 0.4))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.'\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the sum of the bin's current capacity and the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item**2) * np.sqrt(bins) / (np.log(bins + item)))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: \\nThe new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the item size, plus the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the cube root of the logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(item)) + (bins / np.cbrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item**2) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: 'The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the logarithm of the item divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.'\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.log(item) / np.cbrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its square root, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity.\\n\\nNew code:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.sqrt(item))) + (np.sqrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the fourth root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.power(item, 0.25) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the logarithm of the item size, plus the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2.0\\n scores = (bins / np.log(item)) + (bins / np.sqrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity. This algorithm also takes into account an additional parameter 'm', which multiplies the cube root of the bin's current capacity and is subtracted from the score.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n m = 0.1\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins) - (m * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity. This algorithm also takes into account an additional parameter 'm', which multiplies the cube root of the bin's current capacity and is subtracted from the score.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.7\\n m = 0.2\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (np.sqrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins) - (m * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the cube root of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the logarithm of the bin's current capacity plus 5.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.cbrt(item)) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+5))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the bin's current capacity multiplied by the item divided by its square root, plus the square root of the natural logarithm of the item size multiplied by the bin's current capacity, minus the number of times the bin has been used.\\n\\nCode:\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.cbrt(bins) * item / np.sqrt(item) + np.sqrt(np.log(item)) * np.sqrt(bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item divided by its cube root, plus the cube root of the item size divided by the logarithm of the bin's current capacity, minus the product of the number of times the bin has been used and the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item)) / np.cbrt(item)) + (np.cbrt(item) / np.log(bins)) - (np.arange(len(bins)) * np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the square root of the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 3.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.sqrt(np.log(item))) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the natural logarithm of the item divided by its square root, plus the number of times the bin has been used, minus the cube root of the item size multiplied by the square root of the bin's current capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins * np.log(item) / np.sqrt(item) + np.arange(len(bins)) - np.cbrt(item) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity. This algorithm also takes into account an additional parameter 'm', which multiplies the square root of the bin's current capacity and is subtracted from the score.\\n\\n\",\n \"code\": \"def score(item, bins):\\n k = 0.5\\n m = 0.3\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins) - (m * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the sum of the bin's current capacity and the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item**2) * np.sqrt(bins) / (np.log(bins + item)))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: \\nThe new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the item size, plus the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the cube root of the logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(item)) + (bins / np.cbrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item**2) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere's the updated implementation of the score function:\\n\\n```\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins / np.log(item + 1) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins)) / (np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the fourth root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.power(item, 0.25) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the logarithm of the item size, plus the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2.0\\n scores = (bins / np.log(item)) + (bins / np.sqrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity. This algorithm also takes into account an additional parameter 'm', which multiplies the cube root of the bin's current capacity and is subtracted from the score.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.5\\n m = 0.1\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins) - (m * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the square root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity. This algorithm also takes into account an additional parameter 'm', which multiplies the cube root of the bin's current capacity and is subtracted from the score.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 0.7\\n m = 0.2\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (np.sqrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins) - (m * np.cbrt(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.power(item, 1/3) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 10.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+10))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square of the item size, plus the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the natural logarithm of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 3.0\\n scores = (bins / (item * item)) + (bins / np.cbrt(bins - item)) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.log(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the square root of the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size divided by the natural logarithm of the bin's current capacity plus 3.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.sqrt(np.log(item))) + np.arange(len(bins)) + (np.sqrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the cube root of the logarithm of the item divided by its square root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(np.abs(bins - item))) + (bins * np.cbrt(np.log(item)) / np.sqrt(item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity multiplied by the square root of the logarithm of the item size divided by its cube root, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the square root of the bin's current capacity.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(np.abs(bins - item))) + (bins * np.sqrt(np.log(item) / np.cbrt(item))) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n Algorithm description: Assign an item to the bin with the maximum score, calculated as the cube root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its square root, plus the natural logarithm of the bin's current capacity multiplied by the square root of the item size, minus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.cbrt(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.sqrt(item) + np.log(bins) * np.sqrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the cubed root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the cubed root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.cbrt(bins) / np.abs(bins - item)**3) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.cbrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the cube root of the item size multiplied by the logarithm of the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity. This algorithm also takes into account an additional parameter 'm', which multiplies the square root of the bin's current capacity and is subtracted from the score.\\n\\n\",\n \"code\": \"def score(item, bins):\\n k = 0.5\\n m = 0.3\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (np.cbrt(item) * np.log(bins)) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins) - (m * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the sum of the bin's current capacity and the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item**2) * np.sqrt(bins) / (np.log(bins + item)))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: \\nThe new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square root of the item size, plus the bin's current capacity divided by the cube root of the absolute difference between the bin's capacity and the item size, plus the cube root of the logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 1.5\\n scores = (bins / np.sqrt(item)) + (bins / np.cbrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)**2) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item**2) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere's the updated implementation of the score function:\\n\\n```\",\n \"code\": \"def score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / (np.log(bins+1)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / np.abs(bins - item) + bins / np.log(item + 1) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins)) / (np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the square root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.sqrt(item) * np.sqrt(bins) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the square root of the bin's current capacity multiplied by the item divided by its natural logarithm, plus the sine of the bin's current capacity multiplied by the cube root of the item size, minus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.abs(bins - item) + np.sqrt(bins) * item / np.log(item) + np.sin(bins) * np.cbrt(item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size multiplied by the square root of the bin's current capacity, divided by the natural logarithm of the bin's current capacity plus 1.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) * np.sqrt(bins) / (np.log(bins) + 1))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the logarithm of the item size, plus the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the cube root of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 2.0\\n scores = (bins / np.log(item)) + (bins / np.sqrt(np.abs(bins - item))) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.cbrt(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item+1)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the square root of the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the cube root of the item size, plus the number of times the bin has been used, plus the natural logarithm of the item size divided by the cube root of the bin's current capacity plus 2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / np.sqrt(np.abs(bins - item))) + (bins / np.cbrt(item)) + np.arange(len(bins)) + (np.log(item) / np.cbrt(bins+2))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 2.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+2))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.power(item, 1/3) / np.log(bins+3))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the absolute difference between the bin's capacity and the item size, plus the bin's current capacity divided by the natural logarithm of the item size, plus the number of times the bin has been used, plus the cube root of the item size divided by the natural logarithm of the bin's current capacity plus 10.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) + (bins / np.log(item)) + np.arange(len(bins)) + (np.cbrt(item) / np.log(bins+10))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score by calculating the bin's current capacity divided by the square of the item size, plus the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the cube root of the natural logarithm of the item multiplied by the bin's current capacity, minus the square of the number of times the bin has been used, divided by the natural logarithm of the bin's current capacity, and the addition of a constant factor 'k' multiplied by the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n k = 3.0\\n scores = (bins / (item * item)) + (bins / np.cbrt(bins - item)) + (np.cbrt(np.log(item)) * bins) - (np.square(np.arange(len(bins))) / np.log(bins)) + (k * bins)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))**2 + np.exp(np.log(item) * np.arange(len(bins))) - np.arctan(bins)\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used, multiplied by a constant factor.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant = 0.5 # Adjust this constant to control the weight of the square root term\\n scores = bins / (np.exp(bins - item)) + constant * np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, plus the product of the square root of the number of times the bin has been used and the square root of the item size.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.exp(bins - item)) + np.sqrt(np.arange(len(bins))) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.exp(bins - item)) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the square root of the difference between the bin's capacity and the item size and the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the reciprocal of the absolute difference between the bin's capacity and the item size, divided by the cube root of the number of times the bin has been used, multiplied by a constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant = 1.2 # Adjust this constant to control the weight of the cube root term\\n scores = 1 / np.abs(bins - item) / np.cbrt(np.arange(1, len(bins)+1)) * constant\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin and a certain formula. Bins with larger capacities have lower scores, while bins with smaller capacities have higher scores. Additionally, the score calculation involves a mathematical function that takes into account the current item size and the remaining capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-bins/item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the exponential of the absolute difference between the bin's capacity and the item size, divided by the square root of the number of times the bin has been used, multiplied by a constant factor.\\n\\nCode Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant = 0.7 # Adjust this constant to control the weight of the square root term\\n scores = np.exp(-np.abs(bins - item)) / np.sqrt(np.arange(1, len(bins)+1)) * constant\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the sum of the squared difference between the bin's capacity and the item size, and the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.sqrt(np.square(bins - item)) + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, plus the cube of the number of times the bin has been used.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)**2) + np.arange(len(bins))**3\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size, and the square root of the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(bins - item) + np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(bins - item) + np.arange(len(bins))**2)\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the logarithm of the bin's capacity plus the square of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The modified function assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, considering both the remaining capacity of the bin and the size of the item; the goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = (item / bins[bins != max_capacity]) * bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign an item to the bin with the maximum score, taking into account the rest capacity of each bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on the logarithmic score function, considering the rest capacity of each bin, and aims to minimize the number of used bins.\\n\\nNew algorithm implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = np.log(item) - np.log(bins[mask])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and three times the item size, plus the square of the number of times the bin has been used.\\n\\nImplementation in Python:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - (3 * item)) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score to bins based on their remaining capacity and a penalty for exceeding the maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity == bins] = 0 # Assign a score of 0 to bins with maximum capacity\\n \\n max_capacity = np.max(bins)\\n step = 1\\n while True:\\n score = max_capacity - (item + step)\\n bins_with_capacity = remaining_capacity == step\\n scores[bins_with_capacity] = score\\n step += 1\\n if np.sum(bins_with_capacity) == 0:\\n break\\n \\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n \\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin using a modified formula: ((item ^ (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / (np.log(item + 1) + 1).\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item ** (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 10 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 5 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 4, and then multiplied by a constant factor of 7 instead of 8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 10 instead of 9.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, multiplied by the square root of the bin capacity raised to the power of 2 times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 8 instead of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 8 * (ratio ** 3) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin based on the product of the cube root of the bin capacity raised to the power of three times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 5, then multiplied by a constant factor of 15 instead of 10.\\n\\nHere is the Python implementation of the new score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 15 * np.cbrt(bins) ** (3 * np.arange(len(bins))) * np.log(bins + 5) * ratio_inv\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index. \\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the ratio, a power function of the bin capacity, and a logarithmic function of the bin capacity plus a constant factor of 2, instead of 3 in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 3, then multiplied by the cube root of the bin capacity raised to the power of five times the bin index, and finally multiplied by a constant factor of 10 instead of 9.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio) / (np.log(bins) + 3) * ((bins**(1/3)) ** (5 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1).\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm calculates the score for each bin based on the product of the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 2, and the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 7 instead of 6.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio ** 2) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of four.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description of the new algorithm: The new algorithm calculates the score for each bin based on the square root of the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 7, multiplied by the square root of the bin capacity raised to the power of 2 times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 15.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.sqrt(item / (bins - item))\\n scores = 15 * (ratio ** 7) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm calculates the score for each bin based on the ratio between the item size and the square of the difference between the capacity and the item size, raised to the power of a constant factor of 4, multiplied by the square root of the bin capacity raised to the power of four times the bin index, divided by the natural logarithm of the bin capacity plus 5, and then multiplied by a constant factor of 8 instead of 6.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / ((bins - item) ** 2)\\n scores = 8 * (ratio ** 4) * (np.sqrt(bins) ** (4 * np.arange(len(bins)))) / (np.log(bins) + 5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the square of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the square ratio, a power function of the bin capacity, and a logarithmic function of the bin capacity plus a constant factor of 4 instead of 2 in the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 2\\n scores = ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: The algorithm calculates the scores for each bin using the formula: ((item ^ (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / ((item ** 2) + 1)\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item ** (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / ((item ** 2) + 1)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 10 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 5 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity squared, and a logarithmic function of the bin capacity plus a constant factor of 6 instead of 4 in the previous algorithm.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 6)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the square of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the square ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 5.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 2\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 5)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index. \\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the ratio, a power function of the bin capacity, and a logarithmic function of the bin capacity plus a constant factor of 2, instead of 3 in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 3, then multiplied by the cube root of the bin capacity raised to the power of five times the bin index, and finally multiplied by a constant factor of 10 instead of 9.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio) / (np.log(bins) + 3) * ((bins**(1/3)) ** (5 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1).\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm calculates the score for each bin based on the product of the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 2, and the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 7 instead of 6.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio ** 2) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of four.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description of the new algorithm: The new algorithm calculates the score for each bin based on the square root of the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 7, multiplied by the square root of the bin capacity raised to the power of 2 times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 15.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.sqrt(item / (bins - item))\\n scores = 15 * (ratio ** 7) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the square of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the square ratio, a power function of the bin capacity, and a logarithmic function of the bin capacity plus a constant factor of 4 instead of 2 in the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 2\\n scores = ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: The algorithm calculates the scores for each bin using the formula: ((item ^ (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / ((item ** 2) + 1)\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item ** (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / ((item ** 2) + 1)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the square of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the square ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 5.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 2\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 5)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index. \\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of four times the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 5, then multiplied by the cube root of the bin capacity raised to the power of seven times the bin index, and finally multiplied by a constant factor of 12 instead of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * (ratio) / (np.log(bins) + 5) * ((bins**(1/3)) ** (7 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 3, then multiplied by the cube root of the bin capacity raised to the power of five times the bin index, and finally multiplied by a constant factor of 10 instead of 9.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio) / (np.log(bins) + 3) * ((bins**(1/3)) ** (5 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1).\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 2, then multiplied by the cube root of the bin capacity raised to the power of four times the bin index, and finally multiplied by a constant factor of 11 instead of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 11 * (ratio) / (np.log(bins) + 2) * ((bins**(1/3)) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of four.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, and the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 8 instead of 7.\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 8 * (ratio ** 3) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the square of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the square ratio, a power function of the bin capacity, and a logarithmic function of the bin capacity plus a constant factor of 4 instead of 2 in the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 2\\n scores = ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index. \\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of four times the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of two times the bin index, and then multiplied by a constant factor of 200.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 200 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 200 instead of 100 to increase the scoring range.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 200 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity, raised to the power of four.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.sqrt(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 2, then multiplied by the cube root of the bin capacity raised to the power of four times the bin index, and finally multiplied by a constant factor of 11 instead of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 11 * (ratio) / (np.log(bins) + 2) * ((bins**(1/3)) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of four.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) * (np.log(bins) ** (2 * item)) + 10 * np.log(bins) ** (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index. \\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of four times the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of two times the bin index, and then multiplied by a constant factor of 200.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 200 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 200 instead of 100 to increase the scoring range.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 200 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(new algorithm description): The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of four.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with larger capacities by calculating the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three, with an additional weight term taking into account the inverse square of the ratio.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n weight = 1 / (ratio ** 2)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins)))) * weight\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) * (np.log(bins) ** (2 * item)) + 10 * np.log(bins) ** (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) ** 0.5 + np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) ** 0.5 + np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of two times the bin index, and then multiplied by a constant factor of 200.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 200 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 200 instead of 100 to increase the scoring range.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 200 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(new algorithm description): The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with larger capacities by calculating the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three, with an additional weight term taking into account the inverse square of the ratio.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n weight = 1 / (ratio ** 2)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins)))) * weight\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) * (np.log(bins) ** (2 * item)) + 10 * np.log(bins) ** (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of three times the bin index, and then multiplied by a constant factor of 250.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 250 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item^2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n\\nNew algorithm code:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)^2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of two times the bin index, and then multiplied by a constant factor of 200.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 200 * ratio * (np.log(bins) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula that takes into account the square root of the rest capacity of each bin: ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(new algorithm description): The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with larger capacities by calculating the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three, with an additional weight term taking into account the inverse square of the ratio.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n weight = 1 / (ratio ** 2)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins)))) * weight\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) * (np.log(bins) ** (2 * item)) + 10 * np.log(bins) ** (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of three times the bin index, and then multiplied by a constant factor of 250.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 250 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item^2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n\\nNew algorithm code:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)^2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula that takes into account the square root of the rest capacity of each bin: ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(new algorithm description): The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with larger capacities by calculating the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three, with an additional weight term taking into account the inverse square of the ratio.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n weight = 1 / (ratio ** 2)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins)))) * weight\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) * (np.log(bins) ** (2 * item)) + 10 * np.log(bins) ** (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of three times the bin index, and then multiplied by a constant factor of 250.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 250 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is irrelevant in determining the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) ** 0.5) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item^2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n\\nNew algorithm code:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)^2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula that takes into account the square root of the rest capacity of each bin: ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(new algorithm description): The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with larger capacities by calculating the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three, with an additional weight term taking into account the inverse square of the ratio.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n weight = 1 / (ratio ** 2)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins)))) * weight\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) * (np.log(bins) ** (2 * item)) + 10 * np.log(bins) ** (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of three times the bin index, and then multiplied by a constant factor of 250.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 250 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to prioritize bins with larger rest capacities by assigning higher scores to them. The score function is defined as the product of the item size divided by the difference between the rest capacity of each bin and the item size, raised to the power of 0.5, and the natural exponential function of the logarithm of the rest capacities of the bins multiplied by a factor that depends on the position of the bin in the array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item))**0.5 * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the cube of the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the cube ratio, a power function of the bin capacity, and an exponential function of the bin capacity plus a constant factor of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (item / (bins - item)) ** 3\\n scores = ratio * (np.power(bins, np.arange(len(bins)))) * (np.exp(bins) + 10)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item^2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n\\nNew algorithm code:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)^2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula that takes into account the square root of the rest capacity of each bin: ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(new algorithm description): The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the product of the square root of the difference between the bin's capacity and the item size, and the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item)*(np.arange(len(bins))+1))**(1/2))\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the cube root of the difference between the bin's capacity and the item size and the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.cbrt((bins - item) * np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the product of the cube root of the difference between the bin's capacity and the item size, and the cube root of the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.cbrt((bins - item)*(np.arange(len(bins))+1)**(1/3)))\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the sum of the cube root of the difference between the bin's capacity and the item size, and the cube root of the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.cbrt(bins - item) + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used, multiplied by a constant factor.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant = 0.5 # Adjust this constant to control the weight of the square root term\\n scores = bins / (np.exp(bins - item)) + constant * np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a scaling factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) + (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the cube root of the difference between the bin's capacity and the item size and the cube root of the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.cbrt(bins - item)) * (np.cbrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, plus the product of the square root of the number of times the bin has been used and the square root of the item size.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.exp(bins - item)) + np.sqrt(np.arange(len(bins))) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.exp(bins - item)) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the square root of the difference between the bin's capacity and the item size and the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns an item to the bin with the highest score, calculated as the product of the reciprocal of the absolute difference between the bin's capacity and the item size, and the reciprocal of the number of times the bin has been used, multiplied by a constant factor.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant = 2.0 # Adjust this constant to control the weight of the score function\\n scores = (1 / np.abs(bins - item)) * (1 / np.arange(1, len(bins)+1)) * constant\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the reciprocal of the absolute difference between the bin's capacity and the item size, divided by the cube root of the number of times the bin has been used, multiplied by a constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant = 1.2 # Adjust this constant to control the weight of the cube root term\\n scores = 1 / np.abs(bins - item) / np.cbrt(np.arange(1, len(bins)+1)) * constant\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the square root of the difference between the bin's capacity and the item size and the square root of the number of times the bin has been used, with a weight factor applied to the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_factor = 2 # set the weight factor for the number of times the bin has been used\\n \\n scores = bins / ((np.sqrt(bins - item)) * (np.sqrt(np.arange(len(bins)) + 1) + weight_factor))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * np.arange(1, len(bins) + 1)))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a weighted combination of two factors: the reciprocal of the absolute difference between the bin's capacity and the item size, and the inverse of the square root of the number of times the bin has been used, both multiplied by a constant factor.\",\n \"code\": \"def score(item, bins):\\n constant = 2.0 # Adjust this constant to control the weight of the terms\\n scores = 1 / (np.abs(bins - item) + 1) * (1 / np.sqrt(np.arange(1, len(bins)+1))) * constant\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the square root of the number of times the bin has been used, with a weight factor applied to the number of times the bin has been used.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_factor = 3 # set the weight factor for the number of times the bin has been used\\n \\n scores = bins / (((bins - item)) * (np.sqrt(np.arange(len(bins)) + 1) + weight_factor))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and penalize bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with larger capacities by calculating the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of three, with an additional weight term taking into account the inverse square of the ratio.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n weight = 1 / (ratio ** 2)\\n scores = 15 * ratio * (np.log(bins) ** (3 * np.arange(len(bins)))) * weight\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm aims to prioritize bins with larger capacities and also takes into account the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the log of the bin capacity raised to the power of three.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 30 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) * (np.log(bins) ** (2 * item)) + 10 * np.log(bins) ** (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)). The rest capacity of a bin is relevant in determining the score.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the natural logarithm of the bin capacity raised to the power of three times the bin index, and then multiplied by a constant factor of 250.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 250 * ratio * (np.log(bins) ** (3 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 100 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: (item^3 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 4))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**3 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 4))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm is designed to prioritize bins with larger capacities and also considers the size of the item. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 20 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the item size and the rest capacities of the bins using a set of parameter settings.\",\n \"code\": \"def score(item, bins):\\n scores = (item / (bins - item)) ** 2 * (np.sqrt(2 * bins) ** (2 * np.arange(len(bins)))) * (np.exp(bins) + 3)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item^2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n\\nNew algorithm code:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item**2 / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 3))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm prioritizes bins with larger capacities and penalizes bins with smaller capacities. It calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of twice the bin index, and then multiplied by a constant factor of 10.\\n\",\n \"code\": \"def score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.log(bins) ** (2 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to prioritize bins with smaller capacities and penalize bins with larger capacities. It calculates the score for each bin based on the inverse ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - item) / item\\n scores = 10 * np.log(bins) ** (2 * np.arange(len(bins))) / ratio\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**3)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: (item / ((bins - item)^2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + bins) / ((bins - item)**2)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula that takes into account the square root of the rest capacity of each bin: ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1)).\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.sqrt(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (np.sqrt(bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(new algorithm description): The new algorithm calculates the scores for each bin using a modified formula: ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item + 1) / (bins - item)) * np.exp(np.log(bins + item) * (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, with an updated scoring formula that takes into account the maximum capacity and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n used_bins = len(bins) - np.count_nonzero(bins == max_capacity)\\n scores = (bins.itemsize * (bins / (bins - item))) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(max_capacity+1) - np.log(max_capacity) / (np.log(item)+1) * ((used_bins+1)*(item/max_capacity))\\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the logarithm of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index divided by the weight factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1 / (np.arange(len(bins)) ** 2 + 1)\\n scores = (np.log10(bins) / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / weight\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, divided by the natural logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 2 * (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm considers the ratio of the current item size to the remaining capacity of each bin, multiplied by a logarithmic factor based on the bin index and the bin capacity. It then divides the result by the logarithm of the bin capacity plus 1 to calculate the scores for each bin. \\n\\nThe new algorithm considers the square root of the item size instead of the logarithm and adds a weight factor that decreases as the bin index increases. The weight factor is calculated as the reciprocal of the bin index squared plus 1. \\n\\nNew algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index divided by the weight factor.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1 / (np.arange(len(bins)) ** 2 + 1)\\n scores = (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / weight\\n return scores\",\n \"objective\": 0.02727,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin based on the product of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 3 * (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, divided by the logarithm of the bin capacity plus a constant value of 2, and then multiplied by a constant factor of 5.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 5.5 * (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the product of the square root of the difference between the bin's capacity and the item size, and the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item)*(np.arange(len(bins))+1))**(1/2))\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the log of the item size raised to the power of the bin index, and divided by the log of the bin capacity plus 1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, and divided by the natural logarithm of the bin capacity plus 1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the square root of the difference between the capacity and the item size, multiplied by the logarithm of the item size raised to the power of the bin index, and divided by the logarithm of the bin capacity plus 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (np.log(item) ** np.arange(len(bins))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates the score for each bin based on the sum of the square root of the bin capacity divided by the absolute difference between the bin capacity and the item size, multiplied by the logarithm of the item size raised to the power of the bin index, and divided by the natural logarithm of the bin capacity plus 1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) * (np.log(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly. The score for each bin is calculated as the bin's current capacity divided by the product of the cube root of the difference between the bin's capacity and the item size and the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.cbrt((bins - item) * np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the product of the cube root of the difference between the bin's capacity and the item size, and the cube root of the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.cbrt((bins - item)*(np.arange(len(bins))+1)**(1/3)))\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the item size raised to the power of the bin index, and divided by the natural logarithm of the bin capacity plus 1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (item ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm calculates the score for each bin based on a modified form of the logarithm of the bin capacity divided by the difference between the capacity and the item size, multiplied by the item size raised to the power of the bin index divided by a weight factor inversely proportional to the sum of the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1 / np.sum(bins)\\n scores = (np.log1p(bins) / (bins - item)) * (item ** np.arange(len(bins))) / weight\\n return scores\",\n \"objective\": 0.03662,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a scaling factor of 3.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.cbrt(bins - item) + (3 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the sum of the cube root of the difference between the bin's capacity and the item size, and the cube root of the number of times the bin has been used.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.cbrt(bins - item) + np.cbrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the exponential of the difference between the bin's capacity and the item size, plus the logarithm of the number of times the bin has been used, multiplied by a constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant = 0.8 # Adjust this constant to control the weight of the logarithm term\\n scores = bins / (np.exp(bins - item)) + constant * np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, giving higher scores to bins that have more available capacity and lower scores to bins that are already close to their maximum capacity, thereby promoting the assignment of items to bins with maximum rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((np.log(bins) / (bins - item)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, and a scaling factor, giving higher scores to bins that have more available capacity and lower scores to bins that are already close to their maximum capacity, thereby promoting the assignment of items to bins with maximum rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 0.5\\n scores = np.exp((np.log(bins) / (bins - item)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the exponential function raised to the power of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index plus 1, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 2.\\n\\nNew algorithm implementation in Python:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / (bins - item)\\n scores = 2 * np.exp(ratio) * (np.sqrt(bins) ** (np.arange(len(bins)) + 1)) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\n\\nThe new algorithm calculates the scores for each bin using the formula: (bins / (bins - item)) * (item / (np.log(bins) * np.log(item))) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1).\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (item / (np.log(bins) * np.log(item))) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, with an updated scoring formula that takes into account the maximum capacity and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n used_bins = len(bins) - np.count_nonzero(bins == max_capacity)\\n scores = (bins.itemsize * (bins / (bins - item))) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(max_capacity+1) - np.log(max_capacity) / (np.log(item)+1) * ((used_bins+1)*(item/max_capacity))\\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For the new algorithm, the score for each bin is calculated as the product of the bin capacity divided by the difference between the capacity and the item size, multiplied by the logarithm of the item size raised to the power of the bin index, divided by the square root of the bin capacity plus 1, and then multiplied by a constant factor of 5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 5 * (bins / (bins - item)) * (np.log(item) ** np.arange(len(bins))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the logarithm of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index divided by the weight factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1 / (np.arange(len(bins)) ** 2 + 1)\\n scores = (np.log10(bins) / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / weight\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index plus 1, divided by the natural logarithm of the bin capacity plus the item size plus 1, and then multiplied by a constant factor of 3.\\n\\nNew algorithm implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 3 * (bins / (bins - item)) * ((np.sqrt(item) ** (np.arange(len(bins)) + 1)) / (np.log(bins) + item + 1))\\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new algorithm: The new algorithm calculates the score for each bin based on the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, divided by the logarithm of the bin capacity plus a constant value of 3, and then multiplied by a constant factor of 6.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 6 * (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, divided by the natural logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 2 * (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm considers the ratio of the current item size to the remaining capacity of each bin, multiplied by a logarithmic factor based on the bin index and the bin capacity. It then divides the result by the logarithm of the bin capacity plus 1 to calculate the scores for each bin. \\n\\nThe new algorithm considers the square root of the item size instead of the logarithm and adds a weight factor that decreases as the bin index increases. The weight factor is calculated as the reciprocal of the bin index squared plus 1. \\n\\nNew algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index divided by the weight factor.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1 / (np.arange(len(bins)) ** 2 + 1)\\n scores = (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / weight\\n return scores\",\n \"objective\": 0.02727,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin based on the product of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 3 * (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the product of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, divided by the logarithm of the bin capacity plus a constant value of 2, and then multiplied by a constant factor of 5.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 5.5 * (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the product of the square root of the difference between the bin's capacity and the item size, and the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item)*(np.arange(len(bins))+1))**(1/2))\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the log of the item size raised to the power of the bin index, and divided by the log of the bin capacity plus 1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index, and divided by the natural logarithm of the bin capacity plus 1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.sqrt(item) ** np.arange(len(bins))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the sum of the bin capacity divided by the square root of the difference between the capacity and the item size, multiplied by the logarithm of the item size raised to the power of the bin index, and divided by the logarithm of the bin capacity plus 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (np.log(item) ** np.arange(len(bins))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the sum of the square root of the bin capacity divided by the absolute difference between the bin capacity and the item size, multiplied by the natural logarithm of the item size raised to the power of the bin index, and divided by the logarithm of the bin capacity plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs(bins - item)) * (np.log(item) ** np.arange(len(bins))) / np.log(bins + 1)\\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 7 instead of 5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 7 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, giving higher scores to bins that have more available capacity and lower scores to bins that are already close to their maximum capacity, thereby promoting the assignment of items to bins with maximum rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((np.log(bins) / (bins - item)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, and a scaling factor, giving higher scores to bins that have less available capacity and lower scores to bins that are already close to their maximum capacity, thereby promoting the assignment of items to bins with minimum rest capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 2.0\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+1) + np.log(bins) / (np.log(item)+1) + scaling_factor * (item - bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, and a scaling factor, giving higher scores to bins that have less available capacity and lower scores to bins that are further away from their maximum capacity, thereby promoting the assignment of items to bins with higher rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 1.5\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+1) + np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, and a scaling factor, giving higher scores to bins that have more available capacity and lower scores to bins that are already close to their maximum capacity, thereby promoting the assignment of items to bins with maximum rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 0.5\\n scores = np.exp((np.log(bins) / (bins - item)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, a scaling factor, and a distance factor, giving higher scores to bins that have less available capacity and are closer to their maximum capacity, thereby promoting the assignment of items to bins with higher rest capacity and closer to their maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 2.0\\n distance_factor = 0.5\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log(bins+1) + distance_factor * np.log(item+1)) + np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and two scaling factors, emphasizing both bins closer to their maximum capacity and bins with larger capacity to promote the assignment of items to bins with maximum rest capacity.\\n\\nNew algorithm:\\n1. Initialize two scaling factors: scaling_factor_1 and scaling_factor_2.\\n2. Calculate the scores for each bin using the following formula:\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item))\\n3. Return the scores.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 3.0\\n scaling_factor_2 = 2.0\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and two scaling factors, emphasizing both bins closer to their maximum capacity and bins with larger capacity to promote the assignment of items to bins with maximum rest capacity. It will also include a penalty term to penalize bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 5.0\\n scaling_factor_2 = 3.0\\n \\n # Calculate distance of bins from maximum capacity\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - bins\\n \\n # Calculate scores using the modified formula\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) \\n + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 \\n + scaling_factor_2 * (bins - item)\\n + scaling_factor_2 * distance_from_max)\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the logarithm of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 5 instead of 3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.log(bins / (bins - item))\\n scores = 5 * (ratio * (np.sqrt(bins) ** np.arange(len(bins)))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the logarithm of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 3.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.log(bins / (bins - item))\\n scores = 3 * (ratio * (np.sqrt(bins) ** np.arange(len(bins)))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the logarithm of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index plus 1, divided by the bin capacity.\\n\\nNew algorithm implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.log(bins / (bins - item))\\n scores = ratio * (np.sqrt(bins) ** (np.arange(len(bins)) + 1)) / bins\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the exponential function raised to the power of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index plus 1, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 2.\\n\\nNew algorithm implementation in Python:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / (bins - item)\\n scores = 2 * np.exp(ratio) * (np.sqrt(bins) ** (np.arange(len(bins)) + 1)) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 10.0\\n scaling_factor_2 = 2.0\\n \\n # Calculate distance of bins from maximum capacity\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - bins\\n \\n # Calculate scores using the modified formula\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) \\n + np.log(bins) ** 3 / (np.log(item)+1) * scaling_factor_2 \\n + scaling_factor_2 * (bins - item)\\n + scaling_factor_2 * distance_from_max)\\n \\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, and a scaling factor, giving higher scores to bins that have less available capacity and lower scores to bins that are already close to their maximum capacity, thereby promoting the assignment of items to bins with minimum rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 3.0\\n scores = np.exp((np.log(bins) / (item - bins + 1)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+2) + np.log(bins) / (np.log(item)+2) + scaling_factor * (item - bins + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm calculates the scores for each bin using the formula: (bins / (bins - item)) * (item / ((np.log(bins) + 1) * np.log(item + 1))) + np.exp(np.log(item + 1) * np.arange(len(bins))) - np.log(bins) / (np.log(item + 1) + 1).\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (item / ((np.log(bins) + 1) * np.log(item + 1))) + np.exp(np.log(item + 1) * np.arange(len(bins))) - np.log(bins) / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\n\\nThe new algorithm calculates the scores for each bin using the formula: (bins / (bins - item)) * (item / (np.log(bins) * np.log(item))) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1).\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (item / (np.log(bins) * np.log(item))) + np.exp(np.log(item) * np.arange(len(bins))) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, with an updated scoring formula that takes into account the maximum capacity and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n used_bins = len(bins) - np.count_nonzero(bins == max_capacity)\\n scores = (bins.itemsize * (bins / (bins - item))) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(max_capacity+1) - np.log(max_capacity) / (np.log(item)+1) * ((used_bins+1)*(item/max_capacity))\\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm calculates the score for each bin based on the inverse of the bin capacity divided by the difference between the capacity and the item size, multiplied by the square root of the item size raised to the power of the bin index divided by the weight factor.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1 / (np.arange(len(bins)) ** 2 + 1)\\n scores = (1 / bins) / (bins - item) * (np.sqrt(item) ** np.arange(len(bins))) / weight\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 7.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 9 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 10 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 5 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 7 instead of 5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 7 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the cube root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 10 instead of 8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio) * (np.cbrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, and a scaling factor, giving higher scores to bins that have less available capacity and lower scores to bins that are already close to their maximum capacity, thereby promoting the assignment of items to bins with minimum rest capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 2.0\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log(bins+1) + np.log(bins) / (np.log(item)+1) + scaling_factor * (item - bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 10 * (1 / ratio_inv) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 2 instead of 7.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 2 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins. The score function is modified by considering a penalty term that penalizes bins with less capacity remaining, in order to discourage their usage.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins.max() - bins) * (bins < bins.max())\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1) - penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1).\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and three scaling factors, emphasizing bins closer to their maximum capacity, bins with larger capacity, and bins with capacities closer to the item size to promote the assignment of items to bins with maximum rest capacity. The new algorithm will also incorporate a fourth scaling factor to penalize the assignment of items to bins that are much smaller than the item size, discouraging inefficient bin utilization.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 4.0\\n scaling_factor_2 = 1.5\\n scaling_factor_3 = 2.5\\n scaling_factor_4 = 3.0 # New scaling factor\\n \\n # Calculate the scores for the bins\\n scores = (\\n (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))))\\n ** np.log((bins + 1) * scaling_factor_1)\\n + np.log(bins) ** 2 / (np.log(item) + 1) * scaling_factor_2\\n + scaling_factor_2 * (bins - item) * scaling_factor_3 / (item - bins)\\n - scaling_factor_4 * np.abs(bins - item) # Penalize small bins\\n )\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and three scaling factors, emphasizing bins closer to their maximum capacity, bins with larger capacity, and bins with capacities closer to the item size to promote the assignment of items to bins with maximum rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 4.0\\n scaling_factor_2 = 1.5\\n scaling_factor_3 = 2.5\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item) * scaling_factor_3 / (item - bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, a scaling factor, and a distance factor, giving higher scores to bins that have less available capacity and are closer to their maximum capacity, thereby promoting the assignment of items to bins with higher rest capacity and closer to their maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 2.0\\n distance_factor = 0.5\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log(bins+1) + distance_factor * np.log(item+1)) + np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and two scaling factors, emphasizing both bins closer to their maximum capacity and bins with larger capacity to promote the assignment of items to bins with maximum rest capacity.\\n\\nNew algorithm:\\n1. Initialize two scaling factors: scaling_factor_1 and scaling_factor_2.\\n2. Calculate the scores for each bin using the following formula:\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item))\\n3. Return the scores.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 3.0\\n scaling_factor_2 = 2.0\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and two scaling factors, emphasizing both bins closer to their maximum capacity and bins with larger capacity to promote the assignment of items to bins with maximum rest capacity. It will also include a penalty term to penalize bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 5.0\\n scaling_factor_2 = 3.0\\n \\n # Calculate distance of bins from maximum capacity\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - bins\\n \\n # Calculate scores using the modified formula\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) \\n + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 \\n + scaling_factor_2 * (bins - item)\\n + scaling_factor_2 * distance_from_max)\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the logarithm of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 5 instead of 3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.log(bins / (bins - item))\\n scores = 5 * (ratio * (np.sqrt(bins) ** np.arange(len(bins)))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the logarithm of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index, divided by the logarithm of the bin capacity plus 1, and then multiplied by a constant factor of 3.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.log(bins / (bins - item))\\n scores = 3 * (ratio * (np.sqrt(bins) ** np.arange(len(bins)))) / (np.log(bins) + 1)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the logarithm of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of the bin index plus 1, divided by the bin capacity.\\n\\nNew algorithm implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.log(bins / (bins - item))\\n scores = ratio * (np.sqrt(bins) ** (np.arange(len(bins)) + 1)) / bins\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 5, and then multiplied by a constant factor of 12 instead of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 5)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 10 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 5 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 2, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 5 * (ratio ** 2) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the cube root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 10 instead of 8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio) * (np.cbrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, multiplied by the square root of the bin capacity raised to the power of 2.5 times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 7 instead of 5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio ** 3) * (np.sqrt(bins) ** (2.5 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 10 * (1 / ratio_inv) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 5 instead of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 5 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 7 instead of 5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio ** 3) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins. The score function is modified by considering a penalty term that penalizes bins with less capacity remaining, in order to discourage their usage.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins.max() - bins) * (bins < bins.max())\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1) - penalty\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1).\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and three scaling factors, emphasizing bins closer to their maximum capacity, bins with larger capacity, and bins with capacities closer to the item size to promote the assignment of items to bins with maximum rest capacity. The new algorithm will also incorporate a fourth scaling factor to penalize the assignment of items to bins that are much smaller than the item size, discouraging inefficient bin utilization.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 4.0\\n scaling_factor_2 = 1.5\\n scaling_factor_3 = 2.5\\n scaling_factor_4 = 3.0 # New scaling factor\\n \\n # Calculate the scores for the bins\\n scores = (\\n (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))))\\n ** np.log((bins + 1) * scaling_factor_1)\\n + np.log(bins) ** 2 / (np.log(item) + 1) * scaling_factor_2\\n + scaling_factor_2 * (bins - item) * scaling_factor_3 / (item - bins)\\n - scaling_factor_4 * np.abs(bins - item) # Penalize small bins\\n )\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and three scaling factors, emphasizing bins closer to their maximum capacity, bins with larger capacity, and bins with capacities closer to the item size to promote the assignment of items to bins with maximum rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 4.0\\n scaling_factor_2 = 1.5\\n scaling_factor_3 = 2.5\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item) * scaling_factor_3 / (item - bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, a scaling factor, and a distance factor, giving higher scores to bins that have less available capacity and are closer to their maximum capacity, thereby promoting the assignment of items to bins with higher rest capacity and closer to their maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 2.0\\n distance_factor = 0.5\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log(bins+1) + distance_factor * np.log(item+1)) + np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and two scaling factors, emphasizing both bins closer to their maximum capacity and bins with larger capacity to promote the assignment of items to bins with maximum rest capacity.\\n\\nNew algorithm:\\n1. Initialize two scaling factors: scaling_factor_1 and scaling_factor_2.\\n2. Calculate the scores for each bin using the following formula:\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item))\\n3. Return the scores.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 3.0\\n scaling_factor_2 = 2.0\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\n1. Initialize three scaling factors: scaling_factor_1, scaling_factor_2, and scaling_factor_3.\\n2. Create a numpy array 'indices' with values ranging from 0 to len(bins)-1.\\n3. Calculate the scores for each bin using the following formula:\\n scores = ((np.exp((np.log(bins) / (item - bins)) + np.log(item) * indices) ** (np.log((bins+1) * scaling_factor_1) / scaling_factor_2)) + ((np.log(bins) ** 2) / ((np.log(item) + 1) * scaling_factor_2)) * scaling_factor_3 + (scaling_factor_3 * (bins - item)))\\n4. Return the scores.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 3.0\\n scaling_factor_2 = 2.0\\n scaling_factor_3 = 1.5\\n indices = np.arange(len(bins))\\n scores = ((np.exp((np.log(bins) / (item - bins)) + np.log(item) * indices) ** (np.log((bins+1) * scaling_factor_1) / scaling_factor_2)) + ((np.log(bins) ** 2) / ((np.log(item) + 1) * scaling_factor_2)) * scaling_factor_3 + (scaling_factor_3 * (bins - item)))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and three scaling factors, emphasizing bins closer to their maximum capacity, bins with larger capacity, and bins with capacities closer to the item size to promote the assignment of items to bins with maximum rest capacity. The algorithm parameters are as follows:\\n\\n- Scaling factor 1: This factor emphasizes bins closer to their maximum capacity. Increase this factor to give more weight to bins that are closer to their maximum capacity.\\n\\n- Scaling factor 2: This factor emphasizes bins with larger capacity. Increase this factor to give more weight to bins with larger capacity.\\n\\n- Scaling factor 3: This factor emphasizes bins with capacities closer to the item size. Increase this factor to give more weight to bins with capacities closer to the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 5.0\\n scaling_factor_2 = 2.0\\n scaling_factor_3 = 3.5\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item) * scaling_factor_3 / (item - bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on the item size, the rest capacities of the bins, a scaling factor, and a distance factor squared, giving higher scores to bins with less available capacity and closer to their maximum capacity squared, thereby promoting the assignment of items to bins with higher rest capacity squared and closer to their maximum capacity squared. The algorithm then returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 1.5\\n distance_factor = 0.7\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log(bins+1) + (distance_factor ** 2) * np.log(item+1)) + np.log(bins) / (np.log(item)+1) + scaling_factor * ((bins ** 2) - (item ** 2))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 5 instead of 8.\\n\\nPython Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 5 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 10 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 5 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 4, and then multiplied by a constant factor of 7 instead of 8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 10 instead of 9.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 4, multiplied by the square root of the bin capacity raised to the power of 3 times the bin index, divided by the natural logarithm of the bin capacity plus 4, and then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio ** 4) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 6 instead of 5.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 6 * (ratio ** 3) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 5 instead of 10.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 5 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 7 instead of 5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio ** 3) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 3, then multiplied by the cube root of the bin capacity raised to the power of five times the bin index, and finally multiplied by a constant factor of 10 instead of 9.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio) / (np.log(bins) + 3) * ((bins**(1/3)) ** (5 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1).\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 5, multiplied by the square root of the bin capacity raised to the power of 2 times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 10.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 5 * (ratio ** 5) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and three scaling factors, emphasizing bins closer to their maximum capacity, bins with larger capacity, and bins with capacities closer to the item size to promote the assignment of items to bins with maximum rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 4.0\\n scaling_factor_2 = 1.5\\n scaling_factor_3 = 2.5\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item) * scaling_factor_3 / (item - bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, a scaling factor, and a distance factor, giving higher scores to bins that have less available capacity and are closer to their maximum capacity, thereby promoting the assignment of items to bins with higher rest capacity and closer to their maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 2.0\\n distance_factor = 0.5\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log(bins+1) + distance_factor * np.log(item+1)) + np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\n1. Initialize three scaling factors: scaling_factor_1, scaling_factor_2, and scaling_factor_3.\\n2. Calculate the scores for each bin using the following formula:\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log((bins+1) - item + scaling_factor_1) * (np.log(bins+1) + scaling_factor_2) / np.log(bins+1))) + (scaling_factor_3 / np.log(bins+1))\\n3. Return the scores.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 3.0\\n scaling_factor_2 = 2.0\\n scaling_factor_3 = 1.0\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log((bins+1) - item + scaling_factor_1) * (np.log(bins+1) + scaling_factor_2) / np.log(bins+1))) + (scaling_factor_3 / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 2, then multiplied by the square root of the bin capacity raised to the power of five times the bin index, and finally multiplied by a constant factor of 9 instead of 8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) / (np.log(bins) + 2) * (np.sqrt(bins) ** (5 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\n1. Initialize three scaling factors: scaling_factor_1, scaling_factor_2, and scaling_factor_3.\\n2. Create a numpy array 'indices' with values ranging from 0 to len(bins)-1.\\n3. Calculate the scores for each bin using the following formula:\\n scores = ((np.exp((np.log(bins) / (item - bins)) + np.log(item) * indices) ** (np.log((bins+1) * scaling_factor_1) / scaling_factor_2)) + ((np.log(bins) ** 2) / ((np.log(item) + 1) * scaling_factor_2)) * scaling_factor_3 + (scaling_factor_3 * (bins - item)))\\n4. Return the scores.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 3.0\\n scaling_factor_2 = 2.0\\n scaling_factor_3 = 1.5\\n indices = np.arange(len(bins))\\n scores = ((np.exp((np.log(bins) / (item - bins)) + np.log(item) * indices) ** (np.log((bins+1) * scaling_factor_1) / scaling_factor_2)) + ((np.log(bins) ** 2) / ((np.log(item) + 1) * scaling_factor_2)) * scaling_factor_3 + (scaling_factor_3 * (bins - item)))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for the bins based on the item size, the rest capacities of the bins, and three scaling factors, emphasizing bins closer to their maximum capacity, bins with larger capacity, and bins with capacities closer to the item size to promote the assignment of items to bins with maximum rest capacity. The algorithm parameters are as follows:\\n\\n- Scaling factor 1: This factor emphasizes bins closer to their maximum capacity. Increase this factor to give more weight to bins that are closer to their maximum capacity.\\n\\n- Scaling factor 2: This factor emphasizes bins with larger capacity. Increase this factor to give more weight to bins with larger capacity.\\n\\n- Scaling factor 3: This factor emphasizes bins with capacities closer to the item size. Increase this factor to give more weight to bins with capacities closer to the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_1 = 5.0\\n scaling_factor_2 = 2.0\\n scaling_factor_3 = 3.5\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** np.log((bins+1) * scaling_factor_1) + np.log(bins) ** 2 / (np.log(item)+1) * scaling_factor_2 + scaling_factor_2 * (bins - item) * scaling_factor_3 / (item - bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_Dynamic/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin using a modified formula: ((item ^ (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / (np.log(item + 1) + 1).\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item ** (1 / (bins - item))) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin using a modified formula: ((item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / (np.log(item) + 1).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((item / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1))) / (np.log(item) + 1)\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 9 instead of 8.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 9 * (ratio) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin based on the product of the square root of the bin capacity raised to the power of two times the bin index, the inverse of the difference between the bin capacity and the item size, and the natural logarithm of the bin capacity plus 3, then multiplied by a constant factor of 10 instead of 7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 10 * np.sqrt(bins) ** (2 * np.arange(len(bins))) * np.log(bins + 3) * ratio_inv\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Code:\\n\\n\",\n \"code\": \"def score(item, bins):\\n ratio_inv = 1 / (bins - item)\\n scores = 10 * np.sqrt(bins) ** (3 * np.arange(len(bins))) * np.log(bins + 4) * ratio_inv\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm calculates the score for each bin based on the inverse of the ratio between the bin capacity and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 5 instead of 7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio_inv = (bins - item) / bins\\n scores = 5 * (1 / ratio_inv) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 4, and then multiplied by a constant factor of 7 instead of 8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 7 * (ratio) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 4)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the square root of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 10 instead of 9.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, multiplied by the square root of the bin capacity raised to the power of 2 times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 8 instead of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 8 * (ratio ** 3) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 3, multiplied by the square root of the bin capacity raised to the power of three times the bin index, divided by the natural logarithm of the bin capacity plus 3, and then multiplied by a constant factor of 6 instead of 5.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 6 * (ratio ** 3) * (np.sqrt(bins) ** (3 * np.arange(len(bins)))) / (np.log(bins) + 3)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, multiplied by the logarithm of the bin capacity raised to the power of two times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 12 instead of 10.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 12 * ratio * (np.log(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the ratio between the item size and the difference between the capacity and the item size, then computes the scores for each bin as the product of the ratio, a power function of the bin capacity, and a logarithmic function of the bin capacity plus a constant factor of 2, instead of 3 in the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = ratio * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) * (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for the bins based on the item size and the rest capacities of the bins, considering the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.exp(np.log(item) * np.arange(len(bins))) ** np.log(bins+1) - np.log(bins) / (np.log(item)+1)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 3, then multiplied by the cube root of the bin capacity raised to the power of five times the bin index, and finally multiplied by a constant factor of 10 instead of 9.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 10 * (ratio) / (np.log(bins) + 3) * ((bins**(1/3)) ** (5 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1).\\n\\nHere's the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.exp(np.log(bins) * (np.arange(len(bins)) + 1)) - bins / (np.log(item + 1) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio between the item size and the difference between the capacity and the item size, divided by the natural logarithm of the bin capacity plus 2, then multiplied by the square root of the bin capacity raised to the power of four times the bin index, and finally multiplied by a constant factor of 11 instead of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = item / (bins - item)\\n scores = 11 * (ratio) / (np.log(bins) + 2) * ((bins**(1/2)) ** (4 * np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description of the new algorithm: The new algorithm calculates the score for each bin based on the square root of the ratio between the item size and the difference between the capacity and the item size, raised to the power of a constant factor of 7, multiplied by the square root of the bin capacity raised to the power of 2 times the bin index, divided by the natural logarithm of the bin capacity plus 2, and then multiplied by a constant factor of 15.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = np.sqrt(item / (bins - item))\\n scores = 15 * (ratio ** 7) * (np.sqrt(bins) ** (2 * np.arange(len(bins)))) / (np.log(bins) + 2)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin using a modified formula: ((np.exp(np.log(bins) * np.arange(len(bins))) - 1) / (bins - item)) * np.exp(np.log(bins) * np.arange(len(bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.exp(np.log(bins) * np.arange(len(bins))) - 1) / (bins - item)) * np.exp(np.log(bins) * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for the bins based on the item size, the rest capacities of the bins, a scaling factor, and a distance factor, giving higher scores to bins that have less available capacity and are closer to their maximum capacity, thereby promoting the assignment of items to bins with higher rest capacity and closer to their maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 2.0\\n distance_factor = 0.5\\n scores = np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log(bins+1) + distance_factor * np.log(item+1)) + np.log(bins) / (np.log(item)+1) + scaling_factor * (bins - item)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\n1. Initialize three scaling factors: scaling_factor_a, scaling_factor_b, and scaling_factor_c.\\n2. Calculate the scores for each bin using the following formula:\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log((bins+1) - item + scaling_factor_a) * (np.log(bins+1) + scaling_factor_b) / np.log(bins+1))) + (scaling_factor_c / np.log(bins+1))\\n3. Return the scores.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor_a = 3.5\\n scaling_factor_b = 1.5\\n scaling_factor_c = 0.5\\n scores = (np.exp((np.log(bins) / (item - bins)) + np.log(item) * np.arange(len(bins))) ** (np.log((bins+1) - item + scaling_factor_a) * (np.log(bins+1) + scaling_factor_b) / np.log(bins+1))) + (scaling_factor_c / np.log(bins+1))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.log(bins[bins != bins.max()]) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the item size and the rest capacity of each bin.\\n\\nNew algorithm: \\\"A hybrid approach that combines the strengths of the existing algorithms by weighting the scores based on the distance between the item size and the bin capacity, while also considering the number of bins and the item size.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the weights based on the distance and the number of bins\\n weights = np.exp(-distances / (len(bins) + 1))\\n \\n # Calculate the scores based on the weights and the item size\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * weights[bins != bins.max()]\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin, taking into account the rest capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bin_capacities = np.not_equal(bins, item)\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item\\n \\n # Normalize the bin sizes\\n bin_sizes = bins\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n return scores\",\n \"objective\": 0.05644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n scores[i] = (item + i) % num_bins\\n\\n return scores\",\n \"objective\": 0.07928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(item)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n return scores\",\n \"objective\": 0.09699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of available bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n scores = (bins - item) / (num_bins - np.arange(num_bins))\\n return scores\",\n \"objective\": 0.11037,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size using a logarithmic scale\\n ratios = np.log(bins.astype(float)) - np.log(item)\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12899,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign items to bins based on a scoring function that maximizes the score of each bin while avoiding using bins with the maximum rest capacity.\\n\\nNew algorithm: The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin while avoiding using bins with the maximum rest capacity and also considering the distance between the current item size and the bin capacity.\\n\\nDescription: The new algorithm calculates the distance between the current item size and the bin capacity, and then assigns a score to each bin based on the distance and the remaining capacity. Bins with a smaller distance and more remaining capacity receive higher scores.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n distances = np.abs(bins - item)\\n scores = np.zeros_like(bins)\\n scores[distances <= 1] = 1\\n scores[distances > 1] = np.floor(distances[distances > 1] / item)\\n return scores\",\n \"objective\": 0.12919,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin sizes, and the number of used bins to calculate the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on the item size, bin sizes, and the number of used bins\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.sum(bins != bins.max()) + 1))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores.\\n\\nNew algorithm: \\\"Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores, while also considering the number of used bins and the item size.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity\\n ratio = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n # Add a term to the scores based on the number of used bins and the item size\\n scores += (item / np.sum(bins != bins.max())) * (1 / (np.sum(bins != bins.max()) + 1))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the item size to the rest capacity of each bin, where bins with the largest ratios have the highest scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratio = item / (bins - item)\\n \\n # Calculate the scores for each bin based on the ratio\\n scores = np.maximum(ratio, 1)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the difference between the item size and the rest capacity of the bin while minimizing the distance between the item size and the rest capacity.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the rest capacity of each bin\\n diff = np.abs(bins - item)\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the difference and distance\\n scores = diff - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Use logarithmic scale for both item size and bin sizes\\n item_log = np.log(item)\\n bins_log = np.log(bins)\\n \\n # Calculate the scores using the logarithmic scales\\n scores = np.zeros_like(bins)\\n scores[bins_log != bins_log.max()] = item_log / (bins_log[bins_log != bins_log.max()] - item_log + 1)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin sizes, and the number of used bins to calculate the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on the item size, bin sizes, and the number of used bins\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.sum(bins != bins.max()) + 1))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the item size to the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratio = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores.\\n\\nNew algorithm: \\\"Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores, while also considering the number of used bins and the item size.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity\\n ratio = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n # Add a term to the scores based on the number of used bins and the item size\\n scores += (item / np.sum(bins != bins.max())) * (1 / (np.sum(bins != bins.max()) + 1))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the item size to the rest capacity of each bin, where bins with the largest ratios have the highest scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratio = item / (bins - item)\\n \\n # Calculate the scores for each bin based on the ratio\\n scores = np.maximum(ratio, 1)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the difference between the item size and the rest capacity of the bin while minimizing the distance between the item size and the rest capacity.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the rest capacity of each bin\\n diff = np.abs(bins - item)\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the difference and distance\\n scores = diff - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin sizes, and the number of used bins to calculate the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on the item size, bin sizes, and the number of used bins\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.sum(bins != bins.max()) + 1))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the distance between the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item)\\n \\n # Calculate the score for each bin based on the item size and the distance\\n scores = np.ones_like(bins)\\n scores[dist < item] = (item / (dist[dist < item] + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the item size to the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratio = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores.\\n\\nNew algorithm: \\\"Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores, while also considering the number of used bins and the item size.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity\\n ratio = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n # Add a term to the scores based on the number of used bins and the item size\\n scores += (item / np.sum(bins != bins.max())) * (1 / (np.sum(bins != bins.max()) + 1))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the item size to the rest capacity of each bin, where bins with the largest ratios have the highest scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratio = item / (bins - item)\\n \\n # Calculate the scores for each bin based on the ratio\\n scores = np.maximum(ratio, 1)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Maximize the Sum of the Item Size and the Rest Capacity of the Bin while Minimizing the Distance between the Item Size and the Rest Capacity.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the item size and the rest capacity of each bin\\n sum = bins + item\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the sum and distance\\n scores = sum - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin sizes, and the number of used bins to calculate the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on the item size, bin sizes, and the number of used bins\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.sum(bins != bins.max()) + 1))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the distance between the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item)\\n \\n # Calculate the score for each bin based on the item size and the distance\\n scores = np.ones_like(bins)\\n scores[dist < item] = (item / (dist[dist < item] + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity\\n ratio = item / bins\\n \\n # Calculate the scores for each bin\\n scores = np.clip(ratio, 0, 1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Maximize the Sum of the Item Size and the Rest Capacity of the Bin while Minimizing the Distance between the Item Size and the Rest Capacity.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the item size and the rest capacity of each bin\\n sum = bins + item\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the sum and distance\\n scores = sum - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Exponential Weighting\\\" (BINESW)\",\n \"code\": \"import numpy as np\\n\\ndef binesw_score(item, bins):\\n # Calculate the exponential weighting for each bin\\n weights = np.exp(-np.abs(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the exponential weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the distance between the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item)\\n \\n # Calculate the score for each bin based on the item size and the distance\\n scores = np.ones_like(bins)\\n scores[dist < item] = (item / (dist[dist < item] + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity\\n ratio = item / bins\\n \\n # Calculate the scores for each bin\\n scores = np.clip(ratio, 0, 1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Maximize the Sum of the Item Size and the Rest Capacity of the Bin while Minimizing the Distance between the Item Size and the Rest Capacity.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the item size and the rest capacity of each bin\\n sum = bins + item\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the sum and distance\\n scores = sum - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Exponential Weighting\\\" (BINESW)\",\n \"code\": \"import numpy as np\\n\\ndef binesw_score(item, bins):\\n # Calculate the exponential weighting for each bin\\n weights = np.exp(-np.abs(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the exponential weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the distance between the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item)\\n \\n # Calculate the score for each bin based on the item size and the distance\\n scores = np.ones_like(bins)\\n scores[dist < item] = (item / (dist[dist < item] + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity\\n ratio = item / bins\\n \\n # Calculate the scores for each bin\\n scores = np.clip(ratio, 0, 1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item / np.mean(item)) - np.log((bins - item) / np.mean(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the normalized logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Logarithmic Weighting\\\" (BINLW)\",\n \"code\": \"import numpy as np\\n\\ndef binlw_score(item, bins):\\n # Calculate the logarithmic weighting for each bin\\n weights = np.log(bins / item)\\n \\n # Calculate the scores for each bin by multiplying the logarithmic weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Exponential Weighting\\\" (BINESW)\",\n \"code\": \"import numpy as np\\n\\ndef binesw_score(item, bins):\\n # Calculate the exponential weighting for each bin\\n weights = np.exp(-np.abs(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the exponential weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the distance between the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item)\\n \\n # Calculate the score for each bin based on the item size and the distance\\n scores = np.ones_like(bins)\\n scores[dist < item] = (item / (dist[dist < item] + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity\\n ratio = item / bins\\n \\n # Calculate the scores for each bin\\n scores = np.clip(ratio, 0, 1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item / np.mean(item)) - np.log((bins - item) / np.mean(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the normalized logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Logarithmic Weighting\\\" (BINLW)\",\n \"code\": \"import numpy as np\\n\\ndef binlw_score(item, bins):\\n # Calculate the logarithmic weighting for each bin\\n weights = np.log(bins / item)\\n \\n # Calculate the scores for each bin by multiplying the logarithmic weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Exponential Weighting\\\" (BINESW)\",\n \"code\": \"import numpy as np\\n\\ndef binesw_score(item, bins):\\n # Calculate the exponential weighting for each bin\\n weights = np.exp(-np.abs(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the exponential weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the distance between the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item)\\n \\n # Calculate the score for each bin based on the item size and the distance\\n scores = np.ones_like(bins)\\n scores[dist < item] = (item / (dist[dist < item] + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity\\n ratio = item / bins\\n \\n # Calculate the scores for each bin\\n scores = np.clip(ratio, 0, 1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item / np.mean(item)) - np.log((bins - item) / np.mean(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the normalized logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Logarithmic Weighting\\\" (BINLW)\",\n \"code\": \"import numpy as np\\n\\ndef binlw_score(item, bins):\\n # Calculate the logarithmic weighting for each bin\\n weights = np.log(bins / item)\\n \\n # Calculate the scores for each bin by multiplying the logarithmic weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Exponential Weighting\\\" (BINESW)\",\n \"code\": \"import numpy as np\\n\\ndef binesw_score(item, bins):\\n # Calculate the exponential weighting for each bin\\n weights = np.exp(-np.abs(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the exponential weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, adaptively adjusting the threshold based on the item size and the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the product of the item size and the rest capacity, divided by the sum of the item size and the threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the scores for each bin\\n scores = (item * bins) / (threshold + item)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity\\n ratio = item / bins\\n \\n # Calculate the scores for each bin\\n scores = np.clip(ratio, 0, 1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item / np.mean(item)) - np.log((bins - item) / np.mean(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the normalized logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Logarithmic Weighting\\\" (BINLW)\",\n \"code\": \"import numpy as np\\n\\ndef binlw_score(item, bins):\\n # Calculate the logarithmic weighting for each bin\\n weights = np.log(bins / item)\\n \\n # Calculate the scores for each bin by multiplying the logarithmic weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Exponential Weighting\\\" (BINESW)\",\n \"code\": \"import numpy as np\\n\\ndef binesw_score(item, bins):\\n # Calculate the exponential weighting for each bin\\n weights = np.exp(-np.abs(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the exponential weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, adaptively adjusting the threshold based on the item size and the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the product of the item size and the rest capacity, divided by the sum of the item size and the threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the scores for each bin\\n scores = (item * bins) / (threshold + item)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the scores for each bin using a linear combination of the item size and the bin capacity\\n scores = np.dot(item, bins)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item / np.mean(item)) - np.log((bins - item) / np.mean(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the normalized logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Logarithmic Weighting\\\" (BINLW)\",\n \"code\": \"import numpy as np\\n\\ndef binlw_score(item, bins):\\n # Calculate the logarithmic weighting for each bin\\n weights = np.log(bins / item)\\n \\n # Calculate the scores for each bin by multiplying the logarithmic weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.log(bins[bins != bins.max()]) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratios[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the distance between the item size and the rest capacity to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n distances = np.abs(bins - item)\\n \\n # Calculate the scores based on the distance and the rest capacity\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * np.exp(-distances[bins != bins.max()] / (len(bins) + 1))\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"The algorithm uses a combination of the item size, the number of bins, and the rest capacity of each bin to calculate the scores, with a focus on minimizing the number of used bins and maximizing the use of available space.\\\"\\n\\nPython implementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n # Add a bonus term for using fewer bins\\n scores += np.log(bins.size)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the distance between the item size and the rest capacity to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (bins[bins >= item] - item)\\n scores[bins < item] = 1 / (item - bins[bins < item])\\n scores *= np.abs(bins - item)\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of all feasible bins.\\n2. For each bin, calculate the difference between its size and the minimum size.\\n3. Assign a score to each bin based on the difference, where smaller differences correspond to higher scores.\\n4. Return the scores for all bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum size of all feasible bins\\n min_size = np.min(bins[bins > item])\\n \\n # Calculate the difference between each bin size and the minimum size\\n diff = bins - min_size\\n \\n # Assign a score to each bin based on the difference\\n scores = 1 / (diff + 1)\\n \\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin, taking into account the rest capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Remaining Capacity\\\" (MRCA)\\n\\nMain steps:\\n\\n1. Initialize scores array with zeros.\\n2. Exclude bins with exact capacity using `np.where`.\\n3. Calculate the scores for each bin based on the remaining capacity using `np.where` and `1/bin_capacities`.\\n4. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bin_capacities = np.where(bins != item, bins, 0)\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (bins[bins >= item] - item)\\n scores[bins < item] = 1 / (item - bins[bins < item])\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bin_capacities = np.not_equal(bins, item)\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin, taking into account the rest capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores using the raw sizes\\n scores = (item / bins) * (bins / np.max(bins))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n return scores\",\n \"objective\": 0.05644,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Adaptive Proportional Score with Restricted Capacity\\\" (APSRC)\\n\\nDescription: APSRC assigns an item to the bin with the highest adaptive proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity, adjusted by a factor that decreases as the item size increases.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef apsrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the adaptive factor for each bin\\n adaptive_factor = np.exp(-np.sqrt(item))\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item * adaptive_factor\\n \\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Adaptive Score with Restricted Capacity\\\" (ASRC)\\n\\nDescription: ASRC adaptively assigns an item to the bin with the highest score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity, multiplied by a factor that decreases as the number of used bins increases.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef asrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0) * (1 - np.log(np.sum(bins > 0)))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Exponential Weighting\\\" (BINESW)\",\n \"code\": \"import numpy as np\\n\\ndef binesw_score(item, bins):\\n # Calculate the exponential weighting for each bin\\n weights = np.exp(-np.abs(bins - item))\\n \\n # Calculate the scores for each bin by multiplying the exponential weighting with the item size\\n scores = weights * item\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, adaptively adjusting the threshold based on the item size and the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the product of the item size and the rest capacity, divided by the sum of the item size and the threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the scores for each bin\\n scores = (item * bins) / (threshold + item)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Item-specific Weights\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the item-specific weights for each bin\\n weights = np.ones_like(bins)\\n weights[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) ** 2\\n \\n # Assign an item to the bin with the highest weighted score\\n scores = np.zeros_like(bins)\\n scores[weights == weights.max()] = 1\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin based on the item size and rest capacity\\n scores = np.log(np.ones_like(bins))\\n scores[bins != bins.max()] = np.log((item / (bins[bins != bins.max()] - item + 1)))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the scores for each bin using a linear combination of the item size and the bin capacity\\n scores = np.dot(item, bins)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Dynamic Score with Adaptive Threshold\\\" (DSTAT)\\n\\nDescription: DSTAT assigns an item to the bin with the highest dynamic score, considering the adaptive threshold of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef dstat_score(item, bins):\\n # Calculate the adaptive threshold for each bin\\n threshold = np.minimum(bins, item)\\n \\n # Calculate the dynamic scores for each bin\\n scores = np.zeros_like(bins)\\n scores[threshold > 0] = (item / (threshold[threshold > 0] + 1))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nDescription: MSRC assigns an item to the bin with the highest maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the maximum value of the item size minus the remaining capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.maximum(item - rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the ratio of the item size to the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(rest_capacity, 0, 1) * item\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.log(bins[bins != bins.max()]) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\" (MSRC)\\n\\nMain steps: MSRC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef msrc_score(item, bins):\\n # Calculate the maximum score for each bin\\n max_score = np.max(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, max_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the distance between the item size and the rest capacity to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the rest capacity of each bin\\n distances = np.abs(bins - item)\\n \\n # Calculate the scores based on the distance and the rest capacity\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * np.exp(-distances[bins != bins.max()] / (len(bins) + 1))\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = np.min(bins) - item\\n scores = min_bin_size / bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"The algorithm uses a combination of the item size, the number of bins, and the rest capacity of each bin to calculate the scores, with a focus on minimizing the number of used bins and maximizing the use of available space.\\\"\\n\\nPython implementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n # Add a bonus term for using fewer bins\\n scores += np.log(bins.size)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the remaining capacity to the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the remaining capacity to the item size\\n ratio = (bins - item) / item\\n \\n # Calculate the scores for each bin using a robust scoring method\\n scores = np.abs(np.log(ratio)) + 1\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the distance between the item size and the rest capacity to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (bins[bins >= item] - item)\\n scores[bins < item] = 1 / (item - bins[bins < item])\\n scores *= np.abs(bins - item)\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of all feasible bins.\\n2. For each bin, calculate the difference between its size and the minimum size.\\n3. Assign a score to each bin based on the difference, where smaller differences correspond to higher scores.\\n4. Return the scores for all bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum size of all feasible bins\\n min_size = np.min(bins[bins > item])\\n \\n # Calculate the difference between each bin size and the minimum size\\n diff = bins - min_size\\n \\n # Assign a score to each bin based on the difference\\n scores = 1 / (diff + 1)\\n \\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin, taking into account the rest capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Remaining Capacity\\\" (MRCA)\\n\\nMain steps:\\n\\n1. Initialize scores array with zeros.\\n2. Exclude bins with exact capacity using `np.where`.\\n3. Calculate the scores for each bin based on the remaining capacity using `np.where` and `1/bin_capacities`.\\n4. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bin_capacities = np.where(bins != item, bins, 0)\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the item size to the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratio = item / bins\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.05121,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.log(bins[bins != bins.max()]) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = np.min(bins) - item\\n scores = min_bin_size / bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"The algorithm uses a combination of the item size, the number of bins, and the rest capacity of each bin to calculate the scores, with a focus on minimizing the number of used bins and maximizing the use of available space.\\\"\\n\\nPython implementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n # Add a bonus term for using fewer bins\\n scores += np.log(bins.size)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the product of the item size and the rest capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the item size and the rest capacity of each bin\\n prod = item * bins\\n \\n # Set the score for bins with the maximum capacity as 0\\n prod[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the product by an increasing factor\\n scores = prod / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the ratio of the remaining capacity to the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the remaining capacity to the item size\\n ratio = (bins - item) / item\\n \\n # Calculate the scores for each bin using a robust scoring method\\n scores = np.abs(np.log(ratio)) + 1\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the distance between the item size and the rest capacity to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (bins[bins >= item] - item)\\n scores[bins < item] = 1 / (item - bins[bins < item])\\n scores *= np.abs(bins - item)\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of all feasible bins.\\n2. For each bin, calculate the difference between its size and the minimum size.\\n3. Assign a score to each bin based on the difference, where smaller differences correspond to higher scores.\\n4. Return the scores for all bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum size of all feasible bins\\n min_size = np.min(bins[bins > item])\\n \\n # Calculate the difference between each bin size and the minimum size\\n diff = bins - min_size\\n \\n # Assign a score to each bin based on the difference\\n scores = 1 / (diff + 1)\\n \\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the score for each bin, taking into account the rest capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the difference between the item size and the rest capacity of the bin while minimizing the distance between the item size and the rest capacity.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the rest capacity of each bin\\n diff = np.abs(bins - item)\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the difference and distance\\n scores = diff - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = np.min(bins) - item\\n scores = min_bin_size / bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the remaining capacity of each bin to calculate the score, with a focus on maximizing the number of items that can fit in each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n scores = ratios * (bins - item + 1)\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"The algorithm uses a combination of the item size, the number of bins, and the rest capacity of each bin to calculate the scores, with a focus on minimizing the number of used bins and maximizing the use of available space.\\\"\\n\\nPython implementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n # Add a bonus term for using fewer bins\\n scores += np.log(bins.size)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the product of the item size and the rest capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the item size and the rest capacity of each bin\\n prod = item * bins\\n \\n # Set the score for bins with the maximum capacity as 0\\n prod[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the product by an increasing factor\\n scores = prod / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the difference between the item size and the rest capacity of the bin while minimizing the distance between the item size and the rest capacity.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the rest capacity of each bin\\n diff = np.abs(bins - item)\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the difference and distance\\n scores = diff - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Use logarithmic scale for both item size and bin sizes\\n item_log = np.log(item)\\n bins_log = np.log(bins)\\n \\n # Calculate the scores using the logarithmic scales\\n scores = np.zeros_like(bins)\\n scores[bins_log != bins_log.max()] = item_log / (bins_log[bins_log != bins_log.max()] - item_log + 1)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = np.min(bins) - item\\n scores = min_bin_size / bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the remaining capacity of each bin to calculate the score, with a focus on maximizing the number of items that can fit in each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n scores = ratios * (bins - item + 1)\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"The algorithm uses a combination of the item size, the number of bins, and the rest capacity of each bin to calculate the scores, with a focus on minimizing the number of used bins and maximizing the use of available space.\\\"\\n\\nPython implementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size\\n item_norm = item / np.max(bins)\\n \\n # Normalize the bin sizes\\n bin_sizes = bins / np.max(bins)\\n \\n # Calculate the scores using the normalized sizes\\n scores = (item_norm / bin_sizes) * (bin_sizes / np.max(bin_sizes))\\n \\n # Consider the rest capacity of each bin\\n scores = np.where(bins - item >= 0, scores, 0)\\n \\n # Add a bonus term for using fewer bins\\n scores += np.log(bins.size)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the difference between the item size and the rest capacity of the bin while minimizing the distance between the item size and the rest capacity.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the rest capacity of each bin\\n diff = np.abs(bins - item)\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the difference and distance\\n scores = diff - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Use logarithmic scale for both item size and bin sizes\\n item_log = np.log(item)\\n bins_log = np.log(bins)\\n \\n # Calculate the scores using the logarithmic scales\\n scores = np.zeros_like(bins)\\n scores[bins_log != bins_log.max()] = item_log / (bins_log[bins_log != bins_log.max()] - item_log + 1)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = np.min(bins) - item\\n scores = min_bin_size / bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the remaining capacity of each bin to calculate the score, with a focus on maximizing the number of items that can fit in each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n scores = ratios * (bins - item + 1)\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Adaptive Score with Restricted Capacity\\\" (ASRC)\\n\\nDescription: ASRC adaptively adjusts the score for each bin based on the current item size and the remaining capacity of the bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef asrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the current item size and the remaining capacity\\n scores = np.where(rest_capacity > 0, rest_capacity / (item + 1), 0)\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin sizes, and the number of used bins to calculate the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on the item size, bin sizes, and the number of used bins\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.sum(bins != bins.max()) + 1))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the ratio of the item size to the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity\\n ratio = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a certain threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_score = np.max(bins)\\n \\n # Calculate the restricted capacity for each bin\\n restricted_capacity = np.minimum(bins, max_score)\\n \\n # Calculate the score for each bin based on the restricted capacity\\n scores = np.zeros_like(bins)\\n scores[restricted_capacity > 0] = np.log(item / (restricted_capacity[restricted_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the difference between the item size and the rest capacity of the bin while minimizing the distance between the item size and the rest capacity.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the rest capacity of each bin\\n diff = np.abs(bins - item)\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the difference and distance\\n scores = diff - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Use logarithmic scale for both item size and bin sizes\\n item_log = np.log(item)\\n bins_log = np.log(bins)\\n \\n # Calculate the scores using the logarithmic scales\\n scores = np.zeros_like(bins)\\n scores[bins_log != bins_log.max()] = item_log / (bins_log[bins_log != bins_log.max()] - item_log + 1)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = np.min(bins) - item\\n scores = min_bin_size / bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Proportional Score with Restricted Capacity\\\" (PSRC)\\n\\nDescription: PSRC assigns an item to the bin with the highest proportional score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef psrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the proportional scores for each bin\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = (item / (bins[rest_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and rest capacity\\n scores = np.ones_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1e-6))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin sizes, and the number of used bins to calculate the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on the item size, bin sizes, and the number of used bins\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (1 / (np.sum(bins != bins.max()) + 1))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity using a logarithmic scale\\n inv_remaining_capacity = 1 / (np.log(bins) - np.log(item))\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n # Add a threshold to the scores to prevent them from becoming too large\\n scores = np.minimum(scores, 100)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"The algorithm assigns items to bins based on the inverse of the remaining capacity and the item size, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity and the item size\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n inv_remaining_capacity[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the inverse of the remaining capacity with an increasing factor\\n scores = inv_remaining_capacity * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Minimax Score with Restricted Capacity\\\" (MMRC)\\n\\nDescription: MMRC assigns an item to the bin with the minimum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef mmrc_score(item, bins):\\n # Calculate the minimum score for each bin\\n min_score = np.min(bins)\\n \\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.where(rest_capacity > 0, min_score * rest_capacity, 0)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms aim to assign items to bins while minimizing the number of used bins. They use various methods to calculate scores for each bin based on the remaining capacity and the item size.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Restricted Capacity\\\" (MMSC)\\n\\nDescription: MMSC assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a predetermined threshold. The score for each bin is calculated as the minimum of the maximum capacity and the item size divided by the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef mmsc_score(item, bins):\\n # Calculate the restricted capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin\\n scores = np.clip(bins, item, rest_capacity)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores.\\n\\nNew algorithm: \\\"Assign items to bins based on the ratio of the item size to the remaining capacity of each bin, with bins with the maximum capacity having a score of zero and bins with smaller capacities having higher scores, while also considering the number of used bins and the item size.\\\"\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity\\n ratio = item / (bins - item + 1)\\n \\n # Set the score for bins with the maximum capacity as 0\\n ratio[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratio with an increasing factor\\n scores = ratio * np.arange(1, len(bins)+1)\\n \\n # Add a term to the scores based on the number of used bins and the item size\\n scores += (item / np.sum(bins != bins.max())) * (1 / (np.sum(bins != bins.max()) + 1))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum bin size by subtracting the item size from the maximum bin size.\\n2. Calculate the scores for each bin by dividing the minimum bin size by the rest capacity of each bin.\\n3. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a certain threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_score = np.max(bins)\\n \\n # Calculate the restricted capacity for each bin\\n restricted_capacity = np.minimum(bins, max_score)\\n \\n # Calculate the score for each bin based on the restricted capacity\\n scores = np.zeros_like(bins)\\n scores[restricted_capacity > 0] = np.log(item / (restricted_capacity[restricted_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns items to bins based on the logarithmic difference between the item size and the remaining capacity of each bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the remaining capacity of each bin\\n diff = np.log(item) - np.log(bins - item)\\n \\n # Set the score for bins with the maximum capacity as 0\\n diff[bins == np.max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the logarithmic difference with an increasing factor\\n scores = diff * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the difference between the item size and the rest capacity of the bin while minimizing the distance between the item size and the rest capacity.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the rest capacity of each bin\\n diff = np.abs(bins - item)\\n \\n # Calculate the distance between the item size and the rest capacity of each bin\\n dist = np.abs(bins - item) ** 2\\n \\n # Calculate the score for each bin based on the difference and distance\\n scores = diff - dist\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the highest scores, considering the restrictions of bin capacities and the number of used bins.\\n\\nNew algorithm: \\\"Dynamic Programming with Restricted Capacity\\\" (DPCRC)\\n\\nDescription: DPCRC uses dynamic programming to find the optimal assignment of items to bins, considering the restrictions of bin capacities and the number of used bins. It starts by initializing the scores for each bin as the difference between the item size and the rest capacity of the bin, and then iteratively updates the scores based on the previous scores and the remaining capacities of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef dpcrc_score(item, bins):\\n # Initialize the scores for each bin\\n scores = np.abs(bins - item)\\n \\n # Iteratively update the scores based on the previous scores and the remaining capacities of the bins\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = max(scores[i], scores[i-1] + item)\\n else:\\n scores[i] = max(scores[i], scores[i-1] + bins[i])\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Use logarithmic scale for both item size and bin sizes\\n item_log = np.log(item)\\n bins_log = np.log(bins)\\n \\n # Calculate the scores using the logarithmic scales\\n scores = np.zeros_like(bins)\\n scores[bins_log != bins_log.max()] = item_log / (bins_log[bins_log != bins_log.max()] - item_log + 1)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (bins[bins >= item] / item)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the logarithm of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(bins[bins >= item]) / (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores -= (bins - item) // item\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a certain threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_score = np.max(bins)\\n \\n # Calculate the restricted capacity for each bin\\n restricted_capacity = np.minimum(bins, max_score)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[restricted_capacity > item] = item / (restricted_capacity[restricted_capacity > item] - item + 1)\\n \\n return scores\",\n \"objective\": 0.04749,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.0494,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (np.log(bins[bins >= item]) - np.log(item))\\n return scores\",\n \"objective\": 0.05021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = 1\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = 1\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Calculate the scores for each bin based on the ratio and the inverse of the bin size\\n scores = ratios * (1 / bins)\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n scores[bins == max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.05675,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size and the logarithm of the remaining capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (bins[bins >= item] / item) + np.log(bins[bins >= item])\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size and the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (bins[bins >= item] / item) ** 0.5\\n return scores\",\n \"objective\": 0.09186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of items already placed in each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = np.zeros(num_items)\\n for i in range(num_items):\\n scores[i] = (bins[i] - item) / (num_items - i)\\n return scores\",\n \"objective\": 0.11037,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by assigning items to bins with the highest scores.\\n\\nNew algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the minimum score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by assigning items to bins with the highest scores.\\n\\nNew algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to minimize the maximum score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Adjusted Capacity with Item Size, Bin Utilization, and Greedy Approach\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and greedy approach\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n scores[adjusted_capacity == 0] = 0\\n \\n # Sort the bins by their adjusted capacity in descending order\\n sorted_bins = np.argsort(-adjusted_capacity)\\n \\n # Assign the item to the first bin with the maximum adjusted capacity\\n assigned_bin = sorted_bins[0]\\n \\n # Update the scores for the assigned bin\\n scores[assigned_bin] += adjusted_capacity[assigned_bin]\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin capacity, and utilization to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n # Add a penalty term for bins with high utilization\\n scores -= np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the maximum capacity among all bins.\\n3. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization using the following formula: `score = (item / (adjusted_capacity + 1)) * (1 - max_capacity)`\\n4. Return the scores for the bins.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Exponential Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the exponential score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by assigning items to bins with the highest scores.\\n\\nNew algorithm: \\\"Exponential Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the exponential score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Difference Score\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.max(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by assigning items to bins with the highest scores.\\n\\nNew algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to minimize the average score of the selected bins while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the average score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.max(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Adjusted Capacity with Item Size and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n # Find the maximum adjusted capacity among all bins\\n max_adjusted_capacity = np.max(adjusted_capacity)\\n \\n # Assign the item to the bin with the maximum adjusted capacity\\n assigned_bin = np.argmax(adjusted_capacity)\\n \\n # Update the scores for the assigned bin\\n scores[assigned_bin] += max_adjusted_capacity\\n \\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Logarithmic Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the logarithmic score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.log(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Item Size, Bin Capacity, and Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n # Add a penalty term for bins with high utilization\\n scores -= np.power(np.arange(len(bins)), 2)\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is called \\\"Maximum Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the minimum score for each bin based on the adjusted capacity, item size, and bin utilization\\n min_score = np.minimum(item, adjusted_capacity)\\n \\n # Calculate the maximum score for each bin based on the adjusted capacity, item size, and bin utilization\\n max_score = np.maximum(0, adjusted_capacity - item)\\n \\n # Calculate the scores for each bin based on the minimum and maximum scores\\n scores = np.zeros_like(bins)\\n scores[max_score > 0] = min_score[max_score > 0] / max_score[max_score > 0]\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Different Parameter Settings\\\"\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the minimum score for each bin based on the adjusted capacity, item size, and bin utilization.\\n3. Calculate the maximum score for each bin based on the adjusted capacity, item size, and bin utilization.\\n4. Calculate the scores for each bin based on the minimum and maximum scores, but with different parameter settings.\\n5. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the minimum score for each bin based on the adjusted capacity, item size, and bin utilization\\n min_score = np.minimum(item, adjusted_capacity)\\n \\n # Calculate the maximum score for each bin based on the adjusted capacity, item size, and bin utilization\\n max_score = np.maximum(0, adjusted_capacity - item)\\n \\n # Calculate the scores for each bin based on the minimum and maximum scores, but with different parameter settings\\n scores = np.zeros_like(bins)\\n scores[max_score > 0] = min_score[max_score > 0] / (max_score[max_score > 0] + 1)\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\". It is similar to the previous algorithm but with a different approach to calculate the scores.\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the minimum capacity among all bins.\\n3. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization using the following formula: `score = (item / (adjusted_capacity + 1)) * (1 - min_capacity)`\\n4. Return the scores for the bins.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the minimum capacity among all bins\\n min_capacity = np.min(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins\\n adjusted_ratios = np.log(ratios)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\"\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(1 + np.abs(adjusted_capacity[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the maximum minimum score for each bin based on the adjusted capacity, item size, and bin utilization.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\".\\n\\nThe main steps of this algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the Python implementation of the algorithm:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Adjusted Capacity with Item Size, Bin Utilization, and Greedy Approach\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and greedy approach\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n scores[adjusted_capacity == 0] = 0\\n \\n # Sort the bins by their adjusted capacity in descending order\\n sorted_bins = np.argsort(-adjusted_capacity)\\n \\n # Assign the item to the first bin with the maximum adjusted capacity\\n assigned_bin = sorted_bins[0]\\n \\n # Update the scores for the assigned bin\\n scores[assigned_bin] += adjusted_capacity[assigned_bin]\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin capacity, and utilization to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n # Add a penalty term for bins with high utilization\\n scores -= np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\\n\\nDescription: This algorithm combines the maximum score and the exponential score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with an exponential decay to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum score for each bin\\n max_score = np.zeros_like(bins)\\n max_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n max_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Combine the maximum score and the exponential score to calculate the hybrid score\\n scores = max_score + exp_score\\n \\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the maximum capacity among all bins.\\n3. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization using the following formula: `score = (item / (adjusted_capacity + 1)) * (1 - max_capacity)`\\n4. Return the scores for the bins.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Adaptive Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Exponential Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the exponential score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by assigning items to bins with the highest scores.\\n\\nNew algorithm: \\\"Exponential Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the exponential score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Difference Score\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.max(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by assigning items to bins with the highest scores.\\n\\nNew algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to minimize the average score of the selected bins while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(np.max(bins[adjusted_capacity > 0])))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the average score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.max(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin capacity, and utilization to calculate the score for each bin, but also takes into account the distance between the item and the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n # Add a penalty term for bins with high utilization\\n scores -= np.power(np.arange(len(bins)), 2)\\n \\n # Calculate the distance between the item and the bin\\n distances = np.abs(np.subtract(item, bins))\\n \\n # Add a bonus term for bins with low distance\\n scores += np.power(distances, 2)\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the maximum minimum score for each bin based on the adjusted capacity, item size, and bin utilization.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\".\\n\\nThe main steps of this algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the Python implementation of the algorithm:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Adjusted Capacity with Item Size, Bin Utilization, and Greedy Approach\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and greedy approach\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n scores[adjusted_capacity == 0] = 0\\n \\n # Sort the bins by their adjusted capacity in descending order\\n sorted_bins = np.argsort(-adjusted_capacity)\\n \\n # Assign the item to the first bin with the maximum adjusted capacity\\n assigned_bin = sorted_bins[0]\\n \\n # Update the scores for the assigned bin\\n scores[assigned_bin] += adjusted_capacity[assigned_bin]\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n \\n # Apply linear scaling to the scores to ensure that the minimum score is equal to zero\\n min_score = np.min(scores)\\n scores -= min_score\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\\n\\nDescription: This algorithm combines the maximum score and the exponential score with a linear transformation to favor smaller bins, while also considering the adjusted capacity and bin utilization.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum score for each bin\\n max_score = np.zeros_like(bins)\\n max_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n max_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Calculate the linear transformed score for each bin\\n lin_score = np.zeros_like(bins)\\n lin_score[adjusted_capacity > 0] = (item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n lin_score += np.arange(len(bins))\\n \\n # Combine the maximum score, exponential score, and linear transformed score to calculate the hybrid score\\n scores = max_score + exp_score + lin_score\\n \\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin capacity, and utilization to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n # Add a penalty term for bins with high utilization\\n scores -= np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\\n\\nDescription: This algorithm combines the maximum score and the exponential score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with an exponential decay to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum score for each bin\\n max_score = np.zeros_like(bins)\\n max_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n max_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Combine the maximum score and the exponential score to calculate the hybrid score\\n scores = max_score + exp_score\\n \\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Hybrid Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm combines the exponential score and the minimum score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Calculate the minimum score for each bin\\n min_score = np.zeros_like(bins)\\n min_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n min_score += np.arange(len(bins))\\n \\n # Combine the exponential score and the minimum score to calculate the hybrid score\\n scores = exp_score + min_score\\n \\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Hybrid Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Transformation\\\"\\n\\nDescription: This algorithm combines the maximum score, exponential score, and logarithmic score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with an exponential decay and logarithmic transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum score for each bin\\n max_score = np.zeros_like(bins)\\n max_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n max_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Calculate the logarithmic score for each bin\\n log_score = np.zeros_like(bins)\\n log_score[adjusted_capacity > 0] = np.log(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n log_score += np.arange(len(bins))\\n \\n # Combine the maximum score, exponential score, and logarithmic score to calculate the hybrid score\\n scores = max_score + exp_score + log_score\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm combines the maximum score and the exponential score with linear scaling to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with an exponential decay and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum score for each bin\\n max_score = np.zeros_like(bins)\\n max_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n max_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Combine the maximum score and the exponential score with linear scaling to calculate the hybrid score\\n scores = max_score + exp_score + np.linspace(0, 1, len(bins))\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the maximum capacity among all bins.\\n3. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization using the following formula: `score = (item / (adjusted_capacity + 1)) * (1 - max_capacity)`\\n4. Return the scores for the bins.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Adaptive Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Exponential Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the exponential score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms use a combination of the item size, bin capacity, and bin utilization to calculate the score for each bin. They also consider the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nNew algorithm:\\n\\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the maximum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Hybrid Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm combines the average score and the exponential score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average score for each bin\\n avg_score = np.zeros_like(bins)\\n avg_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n avg_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Combine the average score and the exponential score to calculate the hybrid score\\n scores = avg_score + exp_score\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Adjusted Capacity and Bin Utilization\\\". It is similar to the previous algorithm but with a different approach to calculate the scores.\\n\\nThe main steps of the algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity and the bin utilization.\\n3. Return the scores for the bins.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and the bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms use a combination of the item size, bin capacity, and bin utilization to calculate the score for each bin. They also consider the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nNew algorithm:\\n\\\"Hybrid Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\\n\\nDescription:\\nThis algorithm combines the average-based score and the maximum-minimum score with an exponential decay factor and a linear transformation to favor smaller bins, while also considering the adjusted capacity and bin utilization.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average score for each bin\\n avg_score = np.zeros_like(bins)\\n avg_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n avg_score += np.arange(len(bins))\\n \\n # Calculate the minimum score for each bin\\n min_score = np.zeros_like(bins)\\n min_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n min_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Calculate the linear transformed score for each bin\\n lin_score = np.zeros_like(bins)\\n lin_score[adjusted_capacity > 0] = (item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n lin_score += np.arange(len(bins))\\n \\n # Combine the average score, minimum score, exponential score, and linear transformed score to calculate the hybrid score\\n scores = avg_score + min_score + exp_score + lin_score\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a bin-based decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Adaptive Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores[adjusted_capacity <= 0] = np.exp(-np.abs(adjusted_capacity[adjusted_capacity <= 0])) * (1 - bins[adjusted_capacity <= 0])\\n scores += np.arange(len(bins))\\n \\n # Normalize the scores to ensure that they are comparable across different bins\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription:\\nThis algorithm uses an average-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and averaged item size. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and averaged item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms use a combination of the item size, bin capacity, and bin utilization to calculate the score for each bin. They also consider the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nNew algorithm:\\n\\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms use a combination of the item size, bin capacity, and bin utilization to calculate the score for each bin. They also consider the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nNew algorithm:\\n\\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, and an exponential decay factor. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the maximum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Hybrid Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm combines the average score and the exponential score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average score for each bin\\n avg_score = np.zeros_like(bins)\\n avg_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n avg_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Combine the average score and the exponential score to calculate the hybrid score\\n scores = avg_score + exp_score\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Adjusted Capacity and Bin Utilization\\\". It is similar to the previous algorithm but with a different approach to calculate the scores.\\n\\nThe main steps of the algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity and the bin utilization.\\n3. Return the scores for the bins.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and the bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Nonlinear Scaling\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and nonlinearly scaled item size. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and nonlinearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10) ** 2\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Adjusted Capacity-Based Score with Item Size and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity of each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a bin-based decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\\n\\nDescription: This algorithm uses an item-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, bin utilization, and an exponential decay factor.\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of item size, bin utilization, and exponential decay factors to calculate the score for each bin.\\n\\nNew algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a bin-based approach to calculate the score for each bin, where the score is based backbone idea: The provided algorithms use a combination of item size, bin utilization, and exponential decay factors to calculate the score for each bin.\\n\\nNew algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size. The algorithm also cons uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n3. Return the scores for the bins for assignment.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, and an exponential decay factor. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the maximum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Hybrid Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm combines the average score and the exponential score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average score for each bin\\n avg_score = np.zeros_like(bins)\\n avg_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n avg_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Combine the average score and the exponential score to calculate the hybrid score\\n scores = avg_score + exp_score\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-Size-Based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin based on the item size.\\n2. Calculate the bin utilization based on the sum of the items in each bin.\\n3. Calculate the exponential decay factor based on the bin utilization.\\n4. Calculate the scores for each bin based on the adjusted capacity, bin utilization, and exponential decay factor.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin based on the item size\\n adjusted_capacity = bins - item\\n \\n # Calculate the bin utilization based on the sum of the items in each bin\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the exponential decay factor based on the bin utilization\\n decay_factor = np.exp(-bin_utilization)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins)) * decay_factor\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Adjusted Capacity and Bin Utilization\\\". It is similar to the previous algorithm but with a different approach to calculate the scores.\\n\\nThe main steps of the algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity and the bin utilization.\\n3. Return the scores for the bins.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and the bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, and an exponential decay factor.\\n\\nNew algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay with Nonlinear Scaling\\\"\\n\\nDescription: This algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, and an exponential decay factor, and nonlinearly scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor, and nonlinearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10) ** 2\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Adjusted Capacity-Based Score with Item Size and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity of each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Item Size, Rest Capacity, and Exponential Decay\\\".\\n\\nThe main steps of this algorithm are as follows:\\n\\n1. Calculate the scores for each bin based on the item size, rest capacity, and an exponential decay factor.\\n2. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, rest capacity, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\\n\\nDescription: This algorithm uses an item-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, bin utilization, and an exponential decay factor.\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms use a combination of item size, bin capacity, and bin utilization to calculate the score for each bin. They also use an exponential decay factor to penalize bins with high utilization.\\n\\nNew algorithm:\\n\\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, bin utilization, and an exponential decay factor. The score is calculated using a linear scaling factor to penalize bins with high utilization.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that combines the item size, bin capacity, and bin utilization to calculate the score for each bin while considering the exponential decay factor and the logarithmic scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, and an exponential decay factor. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the maximum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Hybrid Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm combines the average score and the exponential score to calculate the hybrid score for each bin based on the adjusted capacity, item size, and bin utilization, with a non-linear transformation to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average score for each bin\\n avg_score = np.zeros_like(bins)\\n avg_score[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0]))\\n avg_score += np.arange(len(bins))\\n \\n # Calculate the exponential score for each bin\\n exp_score = np.zeros_like(bins)\\n exp_score[adjusted_capacity > 0] = np.exp(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n exp_score += np.arange(len(bins))\\n \\n # Combine the average score and the exponential score to calculate the hybrid score\\n scores = avg_score + exp_score\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the item size and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay with Logarithmic Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and linearly scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Adjusted Capacity and Bin Utilization\\\". It is similar to the previous algorithm but with a different approach to calculate the scores.\\n\\nThe main steps of the algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity and the bin utilization.\\n3. Return the scores for the bins.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and the bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0]))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Exponential Score with Adjusted Capacity, Item Size, and Bin Utilization with Nonlinear Scaling\\\"\\n\\nDescription: This algorithm uses an exponential function to calculate the score for each bin based on the adjusted capacity, item size, and bin utilization, with a nonlinear scaling factor to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10) ** 2\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Adjusted Capacity-Based Score with Item Size and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity of each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and logarithmic scaling to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nAll the provided algorithms aim to assign items to bins based on the item size and the remaining capacity of the bins. They use different methods to calculate the scores for each bin, such as exponential decay, logarithmic scaling, and bin utilization.\\n\\nMy new algorithm:\\n\\\"Bin-based Score with Item Size, Rest Capacity, and Bin Utilization with Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm calculates the scores for each bin based on the item size, rest capacity, and bin utilization, using an exponential decay factor to penalize bins with low remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, rest capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\\n\\nDescription: This algorithm uses an item-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, bin utilization, and an exponential decay factor.\\n\\nMain steps:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the adjusted capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that combines the item size, bin capacity, and bin utilization to calculate the score for each bin while considering the exponential decay factor and linear scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, bin capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm uses a bin-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, item size, and an exponential decay factor. The algorithm also considers the adjusted capacity and exponential decay factors to penalize bins that are close to their capacity limits.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the maximum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the item size and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay with Logarithmic Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with exponential decay\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity) * np.exp(-np.abs(bins[bins > item] - item) / (bins[bins > item] + 1))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Adjusted Capacity and Bin Utilization\\\". It is similar to the previous algorithm but with a different approach to calculate the scores.\\n\\nThe main steps of the algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity and the bin utilization.\\n3. Return the scores for the bins.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity and the bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay with Logarithmic Scaling\\\"\\n\\nDescription:\\nThis algorithm uses an item-based approach to calculate the score for each bin, where the score is based on the adjusted capacity, bin utilization, and an exponential decay factor. The score is calculated using a logarithmic scaling factor to penalize bins with high utilization.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.log(item) / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and logarithmic scaling to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-Based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\\n\\nMain steps:\\n\\n1. Calculate the item-based score for each bin based on the adjusted capacity, bin utilization, and exponential decay.\\n2. Return the scores for the bins for assignment.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the item-based score for each bin\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / (bins[bins > item] + 1))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nAll the provided algorithms aim to assign items to bins based on the item size and the remaining capacity of the bins. They use different methods to calculate the scores for each bin, such as exponential decay, logarithmic scaling, and bin utilization.\\n\\nMy new algorithm:\\n\\\"Bin-based Score with Item Size, Rest Capacity, and Bin Utilization with Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm calculates the scores for each bin based on the item size, rest capacity, and bin utilization, using an exponential decay factor to penalize bins with low remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, rest capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Item Size, Rest Capacity, and Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each item based on the item size, rest capacity, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = item / (rest_capacity[rest_capacity > 0] + 1) * (1 - np.mean(bins[rest_capacity > 0])) * np.exp(-np.abs(rest_capacity[rest_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the adjusted capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that combines the item size, bin capacity, and bin utilization to calculate the score for each bin while considering the exponential decay factor and linear scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, bin capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Dynamic-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Dynamic Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the dynamic capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and dynamic scaling to adaptively favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the dynamic capacity of each bin\\n dynamic_capacity = np.sum(bins) / len(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - dynamic_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item-based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the maximum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the item size and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the minimum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity) * np.log(bins[bins > item] + 1)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay with Logarithmic Scaling\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n \\n # For each bin, update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin Score with Linear Decay\\\". It calculates the scores for each bin based on the linear decay of the distance between the item size and the bin capacity.\\n\\nHere is the implementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the linear decay of the distance between the item size and the bin capacity\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity) * (1 - np.abs(bins[bins > item] - item) / (bins[bins > item] + 1))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and logarithmic scaling to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-Based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\\n\\nMain steps:\\n\\n1. Calculate the item-based score for each bin based on the adjusted capacity, bin utilization, and exponential decay.\\n2. Return the scores for the bins for assignment.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the item-based score for each bin\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / (bins[bins > item] + 1))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nAll the provided algorithms aim to assign items to bins based on the item size and the remaining capacity of the bins. They use different methods to calculate the scores for each bin, such as exponential decay, logarithmic scaling, and bin utilization.\\n\\nMy new algorithm:\\n\\\"Bin-based Score with Item Size, Rest Capacity, and Bin Utilization with Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm calculates the scores for each bin based on the item size, rest capacity, and bin utilization, using an exponential decay factor to penalize bins with low remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, rest capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Item Size, Rest Capacity, and Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each item based on the item size, rest capacity, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = item / (rest_capacity[rest_capacity > 0] + 1) * (1 - np.mean(bins[rest_capacity > 0])) * np.exp(-np.abs(rest_capacity[rest_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the adjusted capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that combines the item size, bin capacity, and bin utilization to calculate the score for each bin while considering the exponential decay factor and linear scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, bin capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the average capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item-based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the item size and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the minimum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity) * np.log(bins[bins > item] + 1)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay with Logarithmic Scaling\\\". It is similar to the original algorithm but with different parameter settings.\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor.\\n3. Update the scores by adding the calculated scores to the previous scores.\\n4. Return the updated scores.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n \\n # Update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin Score with Linear Decay\\\". It calculates the scores for each bin based on the linear decay of the distance between the item size and the bin capacity.\\n\\nHere is the implementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the linear decay of the distance between the item size and the bin capacity\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity) * (1 - np.abs(bins[bins > item] - item) / (bins[bins > item] + 1))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size and the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / bins[bins >= item]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the logarithm of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(bins[bins >= item]) / (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores -= (bins - item) // item\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to maximize the score of the selected bin while considering the available capacity of each bin.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity and Item Size\\\"\\n\\nIn this algorithm, we first adjust the capacity of each bin based on the item size and the remaining capacity after placing the current item in the bin. Then, we calculate the scores for each bin based on the adjusted capacity, the item size, and the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.sin(np.pi * (bins[bins >= item] - item) / item)\\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the logarithm of the item size to the remaining capacity after placing the current item in the bin, multiplied by the square root of the remaining capacity, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(item / (bins[bins >= item] - item)) ** np.log(item) * np.sqrt(bins[bins >= item])\\n return scores\",\n \"objective\": 0.04749,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to maximize the score of the selected bin while considering the available capacity of each bin.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity and Item Size\\\"\\n\\nIn this algorithm, we first adjust the capacity of each bin based on the item size and the remaining capacity after placing the current item in the bin. Then, we calculate the scores for each bin based on the adjusted capacity, the item size, and the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 + np.log(item / (bins[adjusted_capacity > 0] - item)))\\n \\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, multiplied by the inverse of the square root of the remaining capacity.\\n\\nDescription: The new algorithm calculates the score for each bin as the product of the ratio of the item size to the remaining capacity after placing the current item in the bin, and the inverse of the square root of the remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins[bins >= item] - item)) / np.sqrt(bins[bins >= item])\\n return scores\",\n \"objective\": 0.04809,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, multiplied by the inverse of the logarithm of the remaining capacity.\\n\\nDescription: The new algorithm calculates the score for each bin as the product of the ratio of the item size to the remaining capacity after placing the current item in the bin, and the inverse of the logarithm of the remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins[bins >= item] - item)) / np.log(bins[bins >= item])\\n return scores\",\n \"objective\": 0.04829,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a square root adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.sqrt(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.0493,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.0494,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the ratio of the remaining capacity to the item size or the inverse of the bin size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.0495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the square root of the ratio of the item size to the remaining capacity after placing the current item in the bin, multiplied by the logarithm of the remaining capacity.\\n\\nDescription: The new algorithm calculates the score for each bin as the product of the square root of the ratio of the item size to the remaining capacity after placing the current item in the bin, and the logarithm of the remaining capacity.\\n\\nImplementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.sqrt((item / (bins[bins >= item] - item))) * np.log(bins[bins >= item])\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 / (np.log(bins[bins >= item]) - np.log(item))\\n return scores\",\n \"objective\": 0.05021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the logarithm of the item size to the remaining capacity after placing the current item in the bin, multiplied by the square root of the remaining capacity.\\n\\nDescription: The new algorithm calculates the score for each bin as the product of the logarithm of the item size to the remaining capacity after placing the current item in the bin, and the square root of the remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(item / (bins[bins >= item] - item)) * np.sqrt(bins[bins >= item])\\n return scores\",\n \"objective\": 0.05031,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Average Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Transformation\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the average capacity among all bins\\n avg_capacity = np.mean(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - avg_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the maximum capacity among all bins\\n max_capacity = np.max(adjusted_capacity)\\n \\n # Calculate the bin utilization\\n bin_utilization = np.sum(bins) / np.sum(adjusted_capacity)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - max_capacity) * np.exp(-bin_utilization)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and logarithmic scaling to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item-Based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\\n\\nMain steps:\\n\\n1. Calculate the item-based score for each bin based on the adjusted capacity, bin utilization, and exponential decay.\\n2. Return the scores for the bins for assignment.\\n\\nImplementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the item-based score for each bin\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / (bins[bins > item] + 1))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nAll the provided algorithms aim to assign items to bins based on the item size and the remaining capacity of the bins. They use different methods to calculate the scores for each bin, such as exponential decay, logarithmic scaling, and bin utilization.\\n\\nMy new algorithm:\\n\\\"Bin-based Score with Item Size, Rest Capacity, and Bin Utilization with Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm calculates the scores for each bin based on the item size, rest capacity, and bin utilization, using an exponential decay factor to penalize bins with low remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, rest capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Score with Item Size, Rest Capacity, and Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the rest capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[rest_capacity > 0] = item / (rest_capacity[rest_capacity > 0] + 1) * (1 - np.mean(bins[rest_capacity > 0])) * np.exp(-np.abs(rest_capacity[rest_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the adjusted capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that combines the item size, bin capacity, and bin utilization to calculate the score for each bin while considering the exponential decay factor and linear scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size, bin capacity, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) * (1 - np.mean(bins[bins > item])) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Average-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the average capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item-based Score with Adjusted Capacity, Bin Utilization, and Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, bin utilization, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Inverse Hyperbolic Sine Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, and bin utilization using the inverse hyperbolic sine function, which is a smooth and continuous version of the logistic function. The inverse hyperbolic sine function maps the range of inputs from -\\u221e to \\u221e to the range of outputs from -1 to 1, making it suitable for assigning scores to bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = np.arcsinh(item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, bin capacity, and an exponential decay factor to calculate the score for each bin.\\n\\nNew algorithm: \\\"Maximum-Based Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Linear Scaling\\\"\\n\\nDescription: This algorithm uses a combination of the maximum capacity, item size, and bin utilization to calculate the score for each bin, with an exponential decay factor and linear scaling to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - max_capacity) * np.exp(-np.abs(bins[bins > item] - item) / 10) * (item / 10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores for each bin based on the item size and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - avg_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of this algorithm are:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of the algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and a logarithmic decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.log(bins[adjusted_capacity > 0])) * np.log(10)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization with Exponential Decay and Logarithmic Scaling\\\"\\n\\nDescription: This algorithm calculates the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, bin utilization, and an exponential decay factor, and logarithmically scaled item size\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.min(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Adjusted Capacity, Item Size, and Bin Utilization with Logarithmic Decay\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the minimum capacity of all bins.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay.\\n3. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization with logarithmic decay\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity) * np.log(bins[bins > item] + 1)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Score with Adjusted Capacity, Item Size, and Exponential Decay with Logarithmic Scaling\\\". It is similar to the original algorithm but with different parameter settings.\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the adjusted capacity for each bin by subtracting the item size from the bin capacity.\\n2. Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor.\\n3. Update the scores by adding the calculated scores to the previous scores.\\n4. Return the updated scores.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and an exponential decay factor\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (1 - np.mean(bins[adjusted_capacity > 0])) * np.exp(-np.abs(adjusted_capacity[adjusted_capacity > 0]) / 10) * np.log(item)\\n \\n # Update the scores by adding the calculated scores to the previous scores\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum-Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin Score with Linear Decay\\\". It calculates the scores for each bin based on the linear decay of the distance between the item size and the bin capacity.\\n\\nHere is the implementation in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum capacity of all bins\\n min_capacity = np.min(bins)\\n \\n # Calculate the scores for each bin based on the linear decay of the distance between the item size and the bin capacity\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] + 1) * (1 - min_capacity) * (1 - np.abs(bins[bins > item] - item) / (bins[bins > item] + 1))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > 0] = item / bins[bins > 0]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)), 0, 1)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] * (1 / item))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the logarithm of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(bins[bins >= item]) / (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores -= (bins - item) // item\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(item / (bins[bins >= item] - item), 0, 1)\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nDescription: Assign scores to bins based on the ratio of the item size to the minimum capacity of the bin, with a logarithmic adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = bins.min()\\n scores = np.zeros_like(bins)\\n scores[bins >= min_bin_size] = np.log(item / (min_bin_size + bins[bins >= min_bin_size]))\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins > item] = np.log(item / (bins[bins > item] - item))\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to maximize the score of the selected bin while considering the available capacity of each bin.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity and Item Size\\\"\\n\\nIn this algorithm, we first adjust the capacity of each bin based on the item size and the remaining capacity after placing the current item in the bin. Then, we calculate the scores for each bin based on the adjusted capacity, the item size, and the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a linear adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = bins - item\\n scores = np.zeros_like(bins)\\n scores[min_bin_size > 0] = item / min_bin_size[min_bin_size > 0]\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.sin(np.pi * (bins[bins >= item] - item) / item)\\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the logarithm of the item size to the remaining capacity after placing the current item in the bin, multiplied by the square root of the remaining capacity, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(item / (bins[bins >= item] - item)) ** np.log(item) * np.sqrt(bins[bins >= item])\\n return scores\",\n \"objective\": 0.04749,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to maximize the score of the selected bin while considering the available capacity of each bin.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity and Item Size\\\"\\n\\nIn this algorithm, we first adjust the capacity of each bin based on the item size and the remaining capacity after placing the current item in the bin. Then, we calculate the scores for each bin based on the adjusted capacity, the item size, and the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = (item / (adjusted_capacity[adjusted_capacity > 0] + 1)) * (1 + np.log(item / (bins[adjusted_capacity > 0] - item)))\\n \\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, multiplied by the inverse of the square root of the remaining capacity.\\n\\nDescription: The new algorithm calculates the score for each bin as the product of the ratio of the item size to the remaining capacity after placing the current item in the bin, and the inverse of the square root of the remaining capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins[bins >= item] - item)) / np.sqrt(bins[bins >= item])\\n return scores\",\n \"objective\": 0.04809,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > 0] = item / bins[bins > 0]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)), 0, 1)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] * (1 / item))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the logarithm of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(bins[bins >= item]) / (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores -= (bins - item) // item\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(item / (bins[bins >= item] - item), 0, 1)\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nDescription: Assign scores to bins based on the ratio of the item size to the minimum capacity of the bin, with a logarithmic adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = bins.min()\\n scores = np.zeros_like(bins)\\n scores[bins >= min_bin_size] = np.log(item / (min_bin_size + bins[bins >= min_bin_size]))\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins > item] = np.log(item / (bins[bins > item] - item))\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size by dividing it by the maximum capacity of all bins\\n norm_item = item / max(bins)\\n \\n # Calculate the scores for each bin based on its capacity and the normalized item size\\n scores = np.zeros_like(bins)\\n scores[bins > norm_item] = np.log(norm_item / (bins[bins > norm_item] - norm_item))\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to maximize the score of the selected bin while considering the available capacity of each bin.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity and Item Size\\\"\\n\\nIn this algorithm, we first adjust the capacity of each bin based on the item size and the remaining capacity after placing the current item in the bin. Then, we calculate the scores for each bin based on the adjusted capacity, the item size, and the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = np.log(item / (bins[bins > item] - item))\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a linear adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = bins - item\\n scores = np.zeros_like(bins)\\n scores[min_bin_size > 0] = item / min_bin_size[min_bin_size > 0]\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.sin(np.pi * (bins[bins >= item] - item) / item)\\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on a linear function of the remaining capacity and item size\\n scores = np.maximum(0, 1 - (bins - item) / item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > 0] = item / bins[bins > 0]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)), 0, 1)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] * (1 / item))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the logarithm of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(bins[bins >= item]) / (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores -= (bins - item) // item\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(item / (bins[bins >= item] - item), 0, 1)\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nDescription: Assign scores to bins based on the ratio of the item size to the minimum capacity of the bin, with a logarithmic adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = bins.min()\\n scores = np.zeros_like(bins)\\n scores[bins >= min_bin_size] = np.log(item / (min_bin_size + bins[bins >= min_bin_size]))\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins > item] = np.log(item / (bins[bins > item] - item))\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size by dividing it by the maximum capacity of all bins\\n norm_item = item / max(bins)\\n \\n # Calculate the scores for each bin based on its capacity and the normalized item size\\n scores = np.zeros_like(bins)\\n scores[bins > norm_item] = np.log(norm_item / (bins[bins > norm_item] - norm_item))\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to maximize the score of the selected bin while considering the available capacity of each bin.\\n\\nNew algorithm: \\\"Maximum Score with Adjusted Capacity and Item Size\\\"\\n\\nIn this algorithm, we first adjust the capacity of each bin based on the item size and the remaining capacity after placing the current item in the bin. Then, we calculate the scores for each bin based on the adjusted capacity, the item size, and the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1)\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = np.log(item / (bins[bins > item] - item))\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a linear adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a linear adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item)\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on a linear function of the remaining capacity and item size\\n scores = np.maximum(0, 1 - (bins - item) / item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > 0] = item / bins[bins > 0]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)), 0, 1)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / sum(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] * (1 / item))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)) + 1, 0, 2)\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the logarithm of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(bins[bins >= item]) / (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores -= (bins - item) // item\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(item / (bins[bins >= item] - item), 0, 1)\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nDescription: Assign scores to bins based on the ratio of the item size to the minimum capacity of the bin, with a logarithmic adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_bin_size = bins.min()\\n scores = np.zeros_like(bins)\\n scores[bins >= min_bin_size] = np.log(item / (min_bin_size + bins[bins >= min_bin_size]))\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n scores[bins > item] = np.log(item / (bins[bins > item] - item))\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the item size by dividing it by the maximum capacity of all bins\\n norm_item = item / max(bins)\\n \\n # Calculate the scores for each bin based on its capacity and the normalized item size\\n scores = np.zeros_like(bins)\\n scores[bins > norm_item] = np.log(norm_item / (bins[bins > norm_item] - norm_item))\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a nonlinear adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = item / (bins[bins > item] - item) ** 2\\n return scores\",\n \"objective\": 0.04477,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins\\n adjusted_ratios = np.log(ratios)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins while assigning items to bins.\\n\\nNew algorithm: \\\"The algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins and minimizing the number of used bins.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins\\n adjusted_ratios = np.log(ratios)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, 1 - (bins - item) / item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > 0] = item / bins[bins > 0]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)), 0, 1)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / sum(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] / item)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] * (1 / (item + 1)))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nDescription: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a cosine adjustment to favor smaller bins.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(np.pi * (bins - item) / item) + 1\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)) + 1, 0, 2)\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the logarithm of the remaining capacity to the item size and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.log(bins[bins >= item]) / (bins[bins >= item] / item) ** (1/3)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins\\n adjusted_ratios = np.log(ratios)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins while assigning items to bins.\\n\\nNew algorithm: \\\"The algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins and minimizing the number of used bins.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins\\n adjusted_ratios = np.log(ratios)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, 1 - (bins - item) / item)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > 0] = item / bins[bins > 0]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nNew algorithm: \\\"Adaptive Score with Dynamic Capacity, Item Size, and Bin Utilization\\\"\\n\\nDescription: This algorithm dynamically adjusts the capacity of each bin based on the current item size and the utilization of each bin, and then calculates the scores based on the adjusted capacity, item size, and bin utilization.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the dynamic capacity for each bin based on the current item size and the utilization of each bin\\n dynamic_capacity = bins - item + np.minimum(bins, item) * (1 - np.power(np.divide(bins, np.max(bins)), 2))\\n \\n # Calculate the scores for each bin based on the dynamic capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[dynamic_capacity > 0] = item / (dynamic_capacity[dynamic_capacity > 0] + 1) * (1 - bins[dynamic_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.clip(np.log(item / (bins[bins >= item] - item)), 0, 1)\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / sum(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the square root of the item size, with a Gaussian adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.exp(-((bins[bins >= item] - item) / item) ** 2) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] / item)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity and the inverse of the item size, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(bins[bins >= item] * (1 / (item + 1)))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms assign scores to bins based on the remaining capacity after placing the current item in the bin.\\n\\nNew algorithm: \\\"Assign a score of 1 to bins whose remaining capacity is equal to the item size, and decrease the score by 1 for each unit increase in remaining capacity.\\\"\\n\\nDescription: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a cosine adjustment to favor smaller bins.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(np.pi * (bins - item) / item) + 1\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by assigning items to bins with the highest scores.\\n\\nNew algorithm: \\\"Minimax Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to minimize the maximum score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\"\\n\\nThis algorithm aims to maximize the score of the selected bin while considering the available capacity of each bin, the size of the current item, and the utilization of each bin.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - bins[adjusted_capacity > 0])\\n scores += np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, bin capacity, and utilization to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the scores for each bin based on the adjusted capacity, item size, and bin utilization\\n scores = np.zeros_like(bins)\\n scores[adjusted_capacity > 0] = item / (adjusted_capacity[adjusted_capacity > 0] + 1) * (1 - np.power(bins[adjusted_capacity > 0], 2))\\n scores += np.arange(len(bins))\\n \\n # Add a penalty term for bins with high utilization\\n scores -= np.power(np.arange(len(bins)), 2)\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is called \\\"Maximum Minimum Score with Adjusted Capacity, Item Size, and Bin Utilization\\\".\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the minimum score for each bin based on the adjusted capacity, item size, and bin utilization\\n min_score = np.minimum(item, adjusted_capacity)\\n \\n # Calculate the maximum score for each bin based on the adjusted capacity, item size, and bin utilization\\n max_score = np.maximum(0, adjusted_capacity - item)\\n \\n # Calculate the scores for each bin based on the minimum and maximum scores\\n scores = np.zeros_like(bins)\\n scores[max_score > 0] = min_score[max_score > 0] / max_score[max_score > 0]\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins\\n adjusted_ratios = np.log(ratios)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"The algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins and minimizing the number of used bins. It also considers the distance between the item size and the bin capacity, giving more weight to bins with a closer fit.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins and bins with a closer fit\\n adjusted_ratios = np.log(ratios) + np.abs(item - bins)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a hyperbolic tangent adjustment to favor smaller bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.tanh(item / (bins[bins >= item] - item))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign scores to bins based on the remaining capacity and the item size, with a non-linear transformation to favor smaller bins.\\n\\nNew algorithm: \\\"Hybrid Score with Logarithmic and Exponential Components\\\"\\n\\nDescription: This algorithm combines the logarithmic and exponential components of the previous two algorithms to create a hybrid score function that favors smaller bins while also considering the item size and the remaining capacity.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted capacity for each bin\\n adjusted_capacity = bins - item\\n \\n # Calculate the logarithmic component of the score\\n log_component = np.log(item / (adjusted_capacity + 1))\\n \\n # Calculate the exponential component of the score\\n exp_component = np.exp(-(adjusted_capacity - item) / (item + 1))\\n \\n # Combine the logarithmic and exponential components to get the final score\\n scores = log_component * exp_component\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins while assigning items to bins.\\n\\nNew algorithm: \\\"The algorithm uses a combination of the item size and the remaining capacity of the bins to calculate the scores, with a focus on maximizing the use of smaller bins and minimizing the number of used bins.\\\"\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the remaining capacity of each bin\\n ratios = item / (bins - item)\\n \\n # Adjust the ratios to favor smaller bins\\n adjusted_ratios = np.log(ratios)\\n \\n # Calculate the scores based on the adjusted ratios\\n scores = adjusted_ratios * (1 - (bins / np.max(bins)))\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item * bins[bins != bins.max()]) / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a logarithmic adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the item size to the remaining capacity after placing the current item in the bin, with a sinusoidal adjustment to favor smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, 1 - (bins / item - 1))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the distance between the current item and the target bin, as well as the distance between the target bin and the next item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distances between the current item and the target bins\\n distances = np.abs(bins - item)\\n \\n # Calculate the scores for each bin based on the distances and the size of the current item\\n scores = np.zeros_like(bins)\\n scores[distances < item] = 1 - distances[distances < item] / item\\n scores[distances >= item] = 1 - (distances[distances >= item] - item) / (bins[distances >= item] - item)\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Use a logarithmic scale for the item size and the bin sizes\\n item_log = np.log(item)\\n bins_log = np.log(bins)\\n \\n # Calculate the scores using the logarithmic scales\\n scores = np.zeros_like(bins)\\n scores[bins_log != bins_log.max()] = (item_log * bins_log[bins_log != bins_log.max()]) / (bins_log[bins_log != bins_log.max()] - item_log + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum bin size\\\"\\n\\nMain steps:\\n\\n1. Calculate the minimum size of each bin by subtracting the current item size from the bin capacity.\\n2. Assign a score to each bin based on the ratio of the item size to the minimum bin size.\\n3. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > 0] = item / bins[bins > 0]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins.max() - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items already assigned to each bin.\\n\\nDescription: The algorithm calculates the distance between the item size and the bin capacity for each bin, and then assigns the item to the bin with the minimum distance. The score for each bin is calculated as the inverse of the distance between the item size and the bin capacity, and is further adjusted based on the number of items already assigned to the bin, and the number of items already assigned to each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Assign the item to the bin with the minimum distance\\n min_distance_index = np.argmin(distances)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins == np.max(bins)))\\n # Set the score for the bin with the minimum distance to 0\\n scores[min_distance_index] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin.\\n\\nDescription: The algorithm calculates the distance between the item size and the bin capacity for each bin, and then assigns the item to the bin with the minimum distance. The score for each bin is calculated as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Assign the item to the bin with the minimum distance\\n min_distance_index = np.argmin(distances)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum distance to 0\\n scores[min_distance_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins >= item, 0, np.clip(bins / item, 0, None))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum score\\\"\\n\\nMain steps:\\n\\n1. Calculate the ratio of rest capacity of each bin to the item size.\\n2. Set the score for bins with equal rest capacity to the maximum capacity as 0.\\n3. Calculate the scores for each bin by multiplying the ratios with the inverse of the bin index (i.e., 1/index).\\n4. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with the inverse of the bin index\\n scores = ratios * (1 / np.arange(1, len(bins)+1))\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of empty bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n scores = np.zeros_like(bins)\\n scores[bins > item] = (num_empty_bins + 1) / (bins[bins > item] / item)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the number of empty bins, and the standard deviation of the remaining bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the number of empty bins\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n # Calculate the standard deviation of the remaining bins\\n std_dev = np.std(bins[bins > item])\\n # Calculate the score for each bin\\n scores = np.zeros_like(bins)\\n scores[bins > item] = (num_empty_bins + 1) / (std_dev / item)\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.05121,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the number of empty bins, and the average capacity of the remaining bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the number of empty bins\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n # Calculate the average capacity of the remaining bins\\n avg_capacity = np.mean(bins[bins > item])\\n # Calculate the score for each bin\\n scores = np.zeros_like(bins)\\n scores[bins > item] = (num_empty_bins + 1) / (avg_capacity / item)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nDescription: The algorithm calculates the distance between the item size and the bin capacity for each bin, and then assigns the item to the bin with the minimum distance. The score for each bin is calculated as the inverse of the distance between the item size and the bin capacity, and is further adjusted based on the number of items already assigned to the bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Assign the item to the bin with the minimum distance\\n min_distance_index = np.argmin(distances)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[min_distance_index] = 0\\n return scores\",\n \"objective\": 0.05453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity.\\n\\nDescription: The algorithm calculates the distance between the item size and the bin capacity for each bin, and then assigns the item to the bin with the minimum distance. The score for each bin is calculated as the inverse of the distance between the item size and the bin capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.sqrt((bins - item)**2)\\n # Select the bin with the closest distance to the item size\\n closest_bin_index = np.argmin(distances)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Set the score for the selected bin to 0\\n scores[closest_bin_index] = 0\\n return scores\",\n \"objective\": 0.05654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nMain steps:\\n\\n1. Calculate the distance between the item size and the bin capacity for each bin.\\n2. Assign the item to the bin with the minimum distance.\\n3. Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, plus the number of items already assigned to the bin.\\n4. Set the score for the bin with the minimum distance to 0.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Assign the item to the bin with the minimum distance\\n min_distance_index = np.argmin(distances)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances + np.arange(len(bins))\\n # Set the score for the bin with the minimum distance to 0\\n scores[min_distance_index] = 0\\n return scores\",\n \"objective\": 0.05735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins, while also considering the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n \\n # Assign the item to the bin with the minimum distance\\n min_distance_index = np.argmin(distances)\\n \\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores += 1 / distances\\n \\n # Set the score for the bin with the minimum distance to 0\\n scores[min_distance_index] = 0\\n \\n return scores\",\n \"objective\": 0.05916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n penalty = 1000\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = np.log(bins[i]) - np.log(item) + penalty\\n else:\\n scores[i] = -np.log(bins[i]) - np.log(item) + penalty\\n\\n return scores\",\n \"objective\": 0.06439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of bins to calculate the scores, with a focus on reducing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n scores = np.zeros(num_bins)\\n\\n for i in range(num_bins):\\n scores[i] = (bins[i] - item) / (num_bins - i)\\n\\n return scores\",\n \"objective\": 0.11037,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\\n\\nNew algorithm: The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the number of times the bin has been used to calculate the score.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size, the distance, and the number of times the bin has been used\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(np.sum(bins))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity)) + (item - bins[i]) / (max_capacity - bins[i])\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Item Size and Remaining Capacity\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = np.log(item / remaining_capacity)\\n \\n # Normalize the scores to ensure they are comparable across bins\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus\\\"\\nThis algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus a bonus for the remaining capacity of the bin.\\n\\nImplementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins)) + np.log(bins)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the scores for each bin based on the item size and the rest capacity of the bins.\\n\\nNew algorithm: \\\"Maximum Score with Item Size Penalty\\\"\\nThis algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various combinations of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: The new algorithm uses a combination of the item size, the rest capacity of each bin, and the ratio of the item size to the maximum capacity of the bins to calculate the score.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity)) * (1 - (item / max_capacity))\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity))\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various combinations of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: The new algorithm uses a combination of the item size, the rest capacity of each bin, and the logarithmic distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * np.log(max_capacity / bins[i])\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the scores for each bin based on the item size and the rest capacity of the bins.\\n\\nNew algorithm: \\\"Maximum Score with Item Size Penalty and Distance Factor\\\"\\nThis algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, and multiplied by a factor that depends on the distance between the item's size and the bin's capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the penalty factor based on the distance\\n penalty_factor = np.exp(-distances / 10)\\n \\n # Calculate the score based on the item's size, the distance, and the number of times the bin has been used\\n scores = bins / (bins - item) - np.arange(len(bins)) * penalty_factor\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a combination of the item size, the rest capacity of each bin, and the square root of the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * np.sqrt(max_capacity / bins[i])\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a certain threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_score = np.max(bins)\\n \\n # Calculate the restricted capacity for each bin\\n restricted_capacity = np.minimum(bins, max_score)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[restricted_capacity > 0] = np.log(item / (restricted_capacity[restricted_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as 0\\n scores = np.zeros_like(bins)\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = bins - item\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.sum(bins <= item)\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is called \\\"Maximum Score with Item Size Bonus\\\". It rewards bins based on their sizes to encourage using larger bins when possible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Add a bonus term based on the size of the bin\\n bonus = (bins - min(bins)) / (max(bins) - min(bins))\\n scores += bonus\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the standard deviation of the remaining bins' capacities to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n \\n # Calculate the score based on the item's size, the distance, and the standard deviation\\n scores = np.log(item / distances) + np.log(distances / std_capacity)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay\\\"\\n\\nIn this algorithm, we modify the previous algorithm by adding an exponential decay factor to the distance penalty term. This factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add an exponential decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay\\\"\\n\\nIn this algorithm, we modify the previous algorithm by adding an exponential decay factor to the distance penalty term. This factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a robust distance metric\\n distances = np.maximum(distances, 1e-6)\\n \\n # Modify the score formula to include more features\\n scores += np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Choose the decay factor based on cross-validation\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty\\\"\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, and the distance between the item size and the bin capacity. The score is higher when the item size is closer to the bin capacity and the rest capacity of the bin is higher.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that considers the item's size, the distance between the item's size and the bin's capacity, the number of times the bin has been used, and the total capacity of all bins to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size, the distance, the number of times the bin has been used, and the total capacity of all bins\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(np.sum(bins)) - np.log(bins)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Linear Decay\\\". It modifies the previous algorithm by replacing the exponential decay factor with a linear decay factor. This factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases.\\n\\nHere is the implementation of the new algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a linear decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * (distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\\n\\nNew algorithm: The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the number of times the bin has been used to calculate the score.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size, the distance, and the number of times the bin has been used\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(np.sum(bins))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity)) + (item - bins[i]) / (max_capacity - bins[i])\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, the rest capacity of each bin, and the ratio of the item size to the maximum capacity of the bins to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (item / max_capacity)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Bin-based Scoring with Item Size and Remaining Capacity\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = np.log(item / remaining_capacity)\\n \\n # Normalize the scores to ensure they are comparable across bins\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus\\\"\\nThis algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus a bonus for the remaining capacity of the bin.\\n\\nImplementation:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins)) + np.log(bins)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Maximize the score of the bin by considering the item size, rest capacity, and usage history.\\n\\nNew algorithm: \\\"Maximum Score with Item Size Penalty, Rest Capacity Bonus, and Usage History Factor\\\"\\n\\nDescription: Assign an item to the bin with the maximum score, considering the item size, rest capacity, and usage history, while ensuring that the total capacity of all bins does not exceed a certain threshold. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus a bonus for the remaining capacity of the bin, and multiplied by a factor that depends on the usage history of the bin.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the usage history factor for each bin\\n usage_history = np.arange(len(bins))\\n usage_history_factor = np.exp(-usage_history / 10)\\n \\n # Calculate the scores for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + np.log(bins) * usage_history_factor\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the scores for each bin based on the item size and the rest capacity of the bins.\\n\\nNew algorithm: \\\"Maximum Score with Item Size Penalty\\\"\\nThis algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The \\\"Maximum Score with Item Size Penalty and Bin Age Factor\\\" algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, and then multiplied by a factor that depends on the age of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the age factor for each bin\\n ages = np.arange(len(bins))\\n age_factor = np.exp(-ages / 10)\\n \\n # Calculate the scores for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) * age_factor\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Bin-based Scoring with Item Size, Remaining Capacity, and Bin Utilization\\\"\\n\\nMain steps: Calculate the remaining capacity for each bin, then calculate the score for each bin based on the item size, the remaining capacity, and the bin utilization. The score is higher when the item size is smaller, the remaining capacity is larger, and the bin utilization is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on the item size, the remaining capacity, and the bin utilization\\n scores = np.log(item / remaining_capacity) + np.sqrt(remaining_capacity) - np.log(bins) + np.log(bins - item + 1)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity))\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Bin-based Scoring with Item Size, Remaining Capacity, and Bin Utilization\\\". It takes into account the utilization of the bins in addition to the item size and remaining capacity.\\n\\nHere is the implementation of the `score` function in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on the item size, remaining capacity, and bin utilization\\n scores = np.log(item / remaining_capacity) + np.log(1 - (bins / np.sum(bins)))\\n \\n # Normalize the scores to ensure they are comparable across bins\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the harmonic mean of the distance between the item size and the maximum capacity of the bins to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 / (1 + (bins[i] / max_capacity)))\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various combinations of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: The new algorithm uses a combination of the item size, the rest capacity of each bin, and the logarithmic distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * np.log(max_capacity / bins[i])\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus\\\" algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Randomness\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add an exponential decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Add a randomness factor to the score\\n randomness_factor = 0.1\\n scores += randomness_factor * np.random.rand(len(bins))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, and the distance between the item size and the bin capacity, with an exponential decay factor applied to the distance penalty. The score is higher when the item size is closer to the bin capacity and the rest capacity of the bin is higher, and the distance penalty decreases exponentially as the distance increases.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply an exponential decay factor to the distance penalty\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02978,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay and Item Size-Bin Capacity Ratio\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, and the ratio of the item size to the bin capacity. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a robust distance metric\\n distances = np.maximum(distances, 1e-6)\\n \\n # Modify the score formula to include more features\\n scores += np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a penalty term for bins that are close to being full\\n penalty = np.exp(-(bins / bins.max()) ** 2)\\n scores -= penalty\\n \\n # Add a bonus term for bins that have a large rest capacity\\n bonus = np.exp((bins.max() - bins) / bins.max())\\n scores += bonus\\n \\n # Add a term to penalize bins with a high item size-bin capacity ratio\\n ratio = item / bins\\n scores -= np.log(ratio)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay\\\"\\n\\nIn this algorithm, we modify the previous algorithm by adding an exponential decay factor to the distance penalty term. This factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add an exponential decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay\\\"\\n\\nIn this algorithm, we modify the previous algorithm by adding an exponential decay factor to the distance penalty term. This factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a robust distance metric\\n distances = np.maximum(distances, 1e-6)\\n \\n # Modify the score formula to include more features\\n scores += np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Choose the decay factor based on cross-validation\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay and Randomness\\\"\\n\\nIn this algorithm, we modify the previous algorithm by adding an exponential decay factor to the distance penalty term and introducing randomness to the score calculation. The exponential decay factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases, while the randomness adds a layer of uncertainty to the score calculation, making it more difficult for the algorithm to converge to a single optimal solution.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add an exponential decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Introduce randomness to the score calculation\\n random_factor = 0.1\\n scores += random_factor * np.random.rand(len(bins))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty\\\"\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, and the distance between the item size and the bin capacity. The score is higher when the item size is closer to the bin capacity and the rest capacity of the bin is higher.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, and the number of times the bin has been used, with an exponential decay factor applied to the distance penalty and the bin utilization factor. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, and the bin has been used fewer times.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply an exponential decay factor to the distance penalty\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a bin utilization factor to the score calculation\\n utilization_factor = 0.5\\n scores += utilization_factor * (1 - (bins / bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various combinations of item size, bin capacity, and distance metrics to calculate scores for assigning an item to a bin.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the total capacity of all bins, with an exponentially decaying learning rate and a self-adaptive learning rate. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the total capacity of all bins is higher.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a bonus term for bins that are far from being full\\n bonus = np.exp((bins / bins.max()) ** 2)\\n scores += bonus\\n \\n # Add a penalty term for bins that are close to being full\\n penalty = np.exp(-(bins / bins.max()) ** 2)\\n scores -= penalty\\n \\n # Choose the decay factor based on cross-validation\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Calculate the self-adaptive learning rate\\n learning_rate = np.minimum(np.exp(-item / (10 * bins.max())), 0.5)\\n \\n # Update the scores based on the self-adaptive learning rate\\n scores = scores * (1 - learning_rate) + learning_rate * np.random.uniform(0, 1, len(bins))\\n \\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus\\\" algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score_log(item, bins):\\n scores = np.log(bins / (bins - item)) - np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various combinations of item size, bin capacity, and distance metrics to calculate scores for assigning an item to a bin.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm modifies the previous algorithm by incorporating an exponentially decaying learning rate to adapt the distance penalty based on the item size and the bin capacity. Additionally, the algorithm includes a self-adaptive learning rate that adjusts the weight of the distance penalty based on the item size and the bin capacity.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a robust distance metric\\n distances = np.maximum(distances, 1e-6)\\n \\n # Modify the score formula to include more features\\n scores += np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Choose the decay factor based on cross-validation\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Calculate the self-adaptive learning rate\\n learning_rate = np.minimum(np.exp(-item / (10 * bins.max())), 0.5)\\n \\n # Update the scores based on the self-adaptive learning rate\\n scores = scores * (1 - learning_rate) + learning_rate * np.random.uniform(0, 1, len(bins))\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Linear Decay and Self-Consistency\\\"\\n\\nIn this algorithm, we modify the previous algorithm by replacing the exponential decay factor with a linear decay factor and removing the randomness component. The linear decay factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases, while the self-consistency ensures that the score calculation is consistent across all bins.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a linear decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * np.minimum(distances / (decay_factor * bins.max()), 1)\\n \\n # Ensure self-consistency by normalizing the scores\\n scores /= np.sum(scores)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Linear Decay\\\". It modifies the previous algorithm by replacing the exponential decay factor with a linear decay factor. This factor reduces the impact of the distance penalty as the distance between the item size and the bin capacity increases.\\n\\nHere is the implementation of the new algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a linear decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * (distances / (decay_factor * bins.max()))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Novel Score Function\\\"\\n\\nThis algorithm uses a different parameter setting for the score function, where the bonus term is based on the inverse of the bin's capacity instead of the square of the ratio of the bin's capacity to the maximum capacity.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size, the distance, and the number of items already placed in the bin\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(np.sum(bins)) - np.log(bins)\\n \\n # Add a bonus term for bins that are far from being full\\n bonus = np.exp(-(bins / bins.max()))\\n scores += bonus\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay and Self-Consistency\\\"\\n\\nIn this algorithm, we modify the previous algorithm by adding a self-consistency term to the score calculation. The self-consistency term ensures that the score of a bin is consistent across all items, which helps to prevent the algorithm from getting stuck in local optima.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add an exponential decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Introduce self-consistency to the score calculation\\n consistency_factor = 0.1\\n scores += consistency_factor * np.mean(np.abs(scores - np.mean(scores)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.0328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm that considers the item size, the distance between the item size and the bin capacity, the number of items already placed in the bin, and the total capacity of all bins to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the distance, and the number of items already placed in the bin\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(np.sum(bins)) - np.log(bins)\\n \\n # Add a penalty term for bins that are close to being full\\n penalty = np.exp(-(bins / bins.max()) ** 2)\\n scores -= penalty\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Adjust the score based on the total capacity of all bins\\n total_capacity = np.sum(bins)\\n scores += np.log(total_capacity) - np.log(bins)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Apply an exponential decay factor to the score\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity, with an exponential decay factor applied to the distance penalty and the bin utilization factor, and a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(utilization_levels)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, and the number of times the bin has been used, with an exponential decay factor applied to the distance penalty and the bin utilization factor. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, and the bin has been used fewer times.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Item Size-Bin Capacity Ratio\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Add a term to penalize bins with a high item size-bin capacity ratio\\n ratio = item / bins\\n scores -= np.log(ratio)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Item Size Penalty, Rest Capacity Bonus, and Exponential Decay\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score, update the rest capacity of the bin accordingly, and decay the score of each bin based on the number of items assigned to it.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to discourage assigning items to bins that are far away from the current bin\\n distance_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= distance_penalty\\n \\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus\\\" algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus and Exponential Decay\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus the bin's rest capacity, and then multiplied by an exponential decay factor based on the bin's usage history.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus and Exponential Decay with Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply logarithmic decay factor based on bin usage history\\n decay_factor = np.log(np.arange(len(bins)) + 1)\\n scores *= decay_factor\\n \\n # Adjust the learning rate based on the number of items assigned to each bin\\n learning_rate = np.exp(-0.5 * np.arange(len(bins)))\\n scores *= learning_rate\\n \\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Item Size Penalty and Rest Capacity Bonus and Exponential Decay\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score and update the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used, plus the bin's rest capacity, and then multiplied by an exponential decay factor based on the bin's usage history.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply logarithmic decay factor based on bin usage history\\n decay_factor = np.log(np.arange(len(bins)) + 1)\\n scores *= decay_factor\\n \\n return scores\",\n \"objective\": 0.02354,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply logarithmic decay factor based on bin usage history\\n decay_factor = np.log(np.arange(len(bins)) + 1)\\n scores *= decay_factor\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Add an exponential decay term to penalize bins with high utilization levels\\n scores -= np.exp(-utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply an exponential decay factor to the distance penalty\\n decay_factor = 0.8\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(utilization_levels)\\n \\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that considers the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\",\n \"code\": \"def score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Add an exponential decay term to penalize bins with high utilization levels\\n scores -= np.exp(-utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is called \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay\\\".\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply an exponential decay factor to the distance penalty\\n decay_factor = 0.8\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply an exponential decay factor to the distance penalty\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, and the distance between the item size and the bin capacity, with an exponential decay factor applied to the distance penalty. The score is higher when the item size is closer to the bin capacity and the rest capacity of the bin is higher, and the distance penalty decreases exponentially as the distance increases.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply a modified decay factor to the distance penalty\\n decay_factor = 0.7\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus and Distance Penalty with Exponential Decay\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, and the distance between the item size and the bin capacity, with an exponential decay factor applied to the distance penalty. The score is higher when the item size is closer to the bin capacity and the rest capacity of the bin is higher, and the distance penalty decreases exponentially as the distance increases.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply a dynamic decay factor to the distance penalty\\n decay_factor = 0.5 * (1 + np.exp(-distances / (item + 1)))\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Randomness\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add an exponential decay factor to the distance penalty term\\n decay_factor = 0.5\\n scores -= decay_factor * np.exp(-distances / (decay_factor * bins.max()))\\n \\n # Add a randomness factor to the score\\n randomness_factor = 0.1\\n scores += randomness_factor * np.random.rand(len(bins))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay\\\". It is similar to the previous algorithm but with different parameter settings.\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the distance between the item size and the bin capacity.\\n2. Calculate the score based on the item size, the rest capacity of the bin, and the distance.\\n3. Apply an exponential decay factor to the distance penalty.\\n4. Add a term to encourage the use of bins with lower utilization levels.\\n5. Set the score to zero if the bin's capacity is equal to the maximum capacity.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Apply an exponential decay factor to the distance penalty\\n decay_factor = 0.7\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity, with an exponential decay factor applied to the distance penalty and the bin utilization, and a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(utilization_levels)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the learning rate of the algorithm, with an exponential decay factor applied to the distance penalty and the bin utilization, and a self-adaptive learning rate that adjusts based on the performance of the algorithm. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the learning rate is higher.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Adjust the learning rate based on the performance of the algorithm\\n learning_rate = 0.1\\n scores += learning_rate * np.random.normal(size=len(bins))\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, and the number of times the bin has been used, with an exponential decay factor applied to the distance penalty and the bin utilization factor. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, and the bin has been used fewer times.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the learning rate of the algorithm, with an exponential decay factor applied to the distance penalty and the bin utilization factor, and a self-adaptive learning rate that adjusts based on the performance of the algorithm. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the learning rate is higher.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Adjust the learning rate based on the performance of the algorithm\\n learning_rate = 0.1\\n scores += learning_rate * np.random.normal(size=len(bins))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity, with an exponential decay factor applied to the distance penalty and the bin utilization, and a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Item Size-Bin Capacity Ratio\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Add a term to penalize bins with a high item size-bin capacity ratio\\n ratio = item / bins\\n scores -= np.log(ratio)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Item Size Penalty, Rest Capacity Bonus, and Exponential Decay\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score, update the rest capacity of the bin accordingly, and decay the score of each bin based on the number of items assigned to it.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Self-Adaptive Score with Item Size Penalty, Rest Capacity Bonus, and Exponential Decay with Different Parameter Settings\\\"\\n\\nDescription:\\nThis algorithm uses a self-adaptive score function with different parameter settings that adjust the weights of the item size penalty, rest capacity bonus, and exponential decay based on the usage history of the bins. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.5\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Apply an item size penalty term\\n item_size_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= item_size_penalty\\n \\n # Apply a rest capacity bonus term\\n rest_capacity_bonus = np.abs(np.arange(len(bins)) - np.argmax(bins))\\n scores += rest_capacity_bonus\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm uses a combination of item size, rest capacity, and utilization level to calculate the score of each bin, with a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Apply an item size penalty term\\n item_size_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= item_size_penalty\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to the scores to encourage items to be placed in bins with lower distances from their target positions\\n distance_penalty = 0.1\\n scores -= distance_penalty * np.abs(np.arange(len(bins)) - np.argmin(bins))\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Apply an item size penalty term\\n item_size_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= item_size_penalty\\n \\n # Apply a rest capacity bonus term\\n rest_capacity_bonus = np.abs(np.arange(len(bins)) - np.argmax(bins))\\n scores += rest_capacity_bonus\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms share the idea of using a score function to evaluate the suitability of each bin for receiving a particular item. The score function typically takes into account the item size, the remaining capacity of the bin, and the utilization level of the bin.\\n\\nNew algorithm:\\n\\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription:\\nThis algorithm uses a score function that takes into account the item size, the remaining capacity of the bin, the utilization level of the bin, and the distance between the current bin and the target position of the item. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Add a distance penalty term to discourage assigning items to bins that are far away from the current bin\\n distance_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= distance_penalty\\n \\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms share the idea of using a score function to evaluate the suitability of each bin for receiving a particular item. The score function typically takes into account the item size, the remaining capacity of the bin, and the utilization level of the bin.\\n\\nNew algorithm:\\n\\\"Self-Adaptive Score with Item Size Penalty, Rest Capacity Bonus, and Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm uses a self-adaptive score function that adjusts the weights of the item size penalty, rest capacity bonus, and exponential decay based on the usage history of the bins. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Apply an item size penalty term\\n item_size_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= item_size_penalty\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to discourage assigning items to bins that are far away from the current bin\\n distance_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= distance_penalty\\n \\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to discourage assigning items to bins that are far away from the current bin\\n distance_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= distance_penalty\\n \\n # Add a bonus term to encourage assigning items to bins with higher rest capacity\\n bonus = np.exp(bins / bins.max())\\n scores += bonus\\n \\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription:\\nThis algorithm uses a score function that takes into account the item size, the remaining capacity of the bin, the utilization level of the bin, and the distance between the current bin and the target position of the item. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Add a distance penalty term to discourage assigning items to bins that are far away from the current bin\\n distance_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= distance_penalty\\n \\n # Add a bonus term to encourage assigning items to bins with higher rest capacity\\n bonus = np.exp(bins / bins.max())\\n scores += bonus\\n \\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate with Different Parameter Settings\\\".\\n\\nThe main steps of my algorithm are as follows:\\n\\n1. Calculate the initial scores based on the item size and the rest capacities of the feasible bins using the same formula as the original algorithm.\\n2. Apply an exponential decay factor to the scores to penalize bins that have been used more frequently.\\n3. Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation.\\n4. Add a distance penalty term to the scores to encourage items to be placed in bins with lower distances from their target positions.\\n5. Return the scores for the bins for assignment.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.9\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.2\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to the scores to encourage items to be placed in bins with lower distances from their target positions\\n distance_penalty = 0.2\\n scores -= distance_penalty * np.abs(np.arange(len(bins)) - np.argmin(bins))\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea:\\nThe provided algorithms share the idea of using a score function to evaluate the suitability of each bin for receiving a particular item. The score function typically takes into account the item size, the remaining capacity of the bin, and the utilization level of the bin.\\n\\nNew algorithm:\\n\\\"Self-Adaptive Score with Item Size Penalty, Rest Capacity Bonus, and Exponential Decay\\\"\\n\\nDescription:\\nThis algorithm uses a self-adaptive score function that adjusts the weights of the item size penalty, rest capacity bonus, and exponential decay based on the usage history of the bins. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"def score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity, with an exponential decay factor applied to the distance penalty and the bin utilization, and a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(utilization_levels)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the learning rate of the algorithm, with an exponential decay factor applied to the distance penalty and the bin utilization, and a self-adaptive learning rate that adjusts based on the performance of the algorithm. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the learning rate is higher.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Adjust the learning rate based on the performance of the algorithm\\n learning_rate = 0.1\\n scores += learning_rate * np.random.normal(size=len(bins))\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use a combination of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, and the number of times the bin has been used, with an exponential decay factor applied to the distance penalty and the bin utilization factor. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, and the bin has been used fewer times.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the learning rate of the algorithm, with an exponential decay factor applied to the distance penalty and the bin utilization factor, and a self-adaptive learning rate that adjusts based on the performance of the algorithm. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the learning rate is higher.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Adjust the learning rate based on the performance of the algorithm\\n learning_rate = 0.1\\n scores += learning_rate * np.random.normal(size=len(bins))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the learning rate of the algorithm, with an exponential decay factor applied to the distance penalty and the bin utilization factor, and a self-adaptive learning rate that adjusts based on the performance of the algorithm. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the learning rate is higher.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Adjust the learning rate based on the performance of the algorithm\\n learning_rate = 0.1\\n scores += learning_rate * np.random.normal(size=len(bins))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Item Size-Bin Capacity Ratio with Modified Distance Weighting\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower. The difference from the previous algorithm is that the distance weighting is modified to take into account the item size and the bin capacity ratio.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Add a term to penalize bins with a high item size-bin capacity ratio\\n ratio = item / bins\\n scores -= np.log(ratio)\\n \\n # Modify the distance weighting to take into account the item size and the bin capacity ratio\\n scores *= np.minimum(1, np.maximum(0, (item / bins) ** 2))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the learning rate of the algorithm, with an exponential decay factor applied to the distance penalty and the bin utilization, and a self-adaptive learning rate that adjusts based on the performance of the algorithm. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the learning rate is higher.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Adjust the learning rate based on the performance of the algorithm\\n learning_rate = 0.1\\n scores += learning_rate * np.random.normal(size=len(bins))\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity, with an exponential decay factor applied to the distance penalty and the bin utilization, and a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the score of each bin based on the item size, the rest capacity of the bin, and other factors.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Item Size-Bin Capacity Ratio\\\"\\n\\nThis algorithm assigns an item to the bin with the highest score, which is calculated based on the item size, the rest capacity of the bin, the distance between the item size and the bin capacity, the number of times the bin has been used, and the ratio of the item size to the bin capacity. The score is higher when the item size is closer to the bin capacity, the rest capacity of the bin is higher, the distance between the item size and the bin capacity is smaller, the bin has been used fewer times, and the ratio of the item size to the bin capacity is lower.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item size, the rest capacity of the bin, and the distance\\n scores = np.log(item / distances) + np.sqrt(distances) + np.log(bins) - np.log(bins - item + 1)\\n \\n # Add a regularization term to penalize large distances\\n scores += 0.1 * np.square(distances)\\n \\n # Choose the decay factor based on the distribution of the data\\n decay_factor = np.mean(distances)\\n scores -= decay_factor * np.exp(-distances / (item + 1))\\n \\n # Apply an exponential decay factor to the bin utilization factor\\n utilization_factor = 0.5\\n scores -= utilization_factor * np.exp(-np.arange(len(bins)))\\n \\n # Add a term to penalize bins with a high item size-bin capacity ratio\\n ratio = item / bins\\n scores -= np.log(ratio)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate with Different Parameter Settings\\\".\\n\\nThe main steps of my algorithm are similar to the original algorithm, but with different parameter settings. Specifically, the decay factor is increased to 0.98, the learning rate is decreased to 0.05, and the distance penalty is increased to 0.2. These changes aim to prioritize the use of bins with higher rest capacities and reduce the impact of distance on the score calculation.\\n\\nHere is the implementation of my algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores with a minimum value added to the denominator and a maximum value added to the numerator\\n scores = np.maximum(bins / (bins - item + 1), 1) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.98\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.05\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to the scores to encourage items to be placed in bins with lower distances from their target positions\\n distance_penalty = 0.2\\n scores -= distance_penalty * np.abs(np.arange(len(bins)) - np.argmin(bins))\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm uses a score function that takes into account the item size, the remaining capacity of the bin, the utilization level of the bin, and the distance between the current bin and the target position of the item. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Add a distance penalty term to the scores to encourage items to be placed in bins with lower distances from their target positions\\n distance_penalty = 0.1\\n scores -= distance_penalty * np.abs(np.arange(len(bins)) - np.argmin(bins))\\n \\n # Apply a bonus to the scores based on the rest capacity of the bins\\n rest_capacity_bonus = 0.1\\n scores += rest_capacity_bonus * (bins - item)\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to the scores to encourage items to be placed in bins with lower distances from their target positions\\n distance_penalty = 0.1\\n scores -= distance_penalty * np.abs(np.arange(len(bins)) - np.argmin(bins))\\n \\n # Apply a bonus to the scores based on the rest capacity of the bins\\n rest_capacity_bonus = 0.1\\n scores += rest_capacity_bonus * (bins - item)\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Using a combination of factors such as item size, rest capacity, and utilization level to calculate the score for each bin.\\n\\nNew algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm uses a score function that takes into account the item size, the remaining capacity of the bin, the utilization level of the bin, and the distance between the current bin and the target position of the item. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Add a distance penalty term to the scores to encourage items to be placed in bins with lower distances from their target positions\\n distance_penalty = 0.1\\n scores -= distance_penalty * np.abs(np.arange(len(bins)) - np.argmin(bins))\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Using a combination of factors such as item size, rest capacity, and utilization level to calculate the score for each bin.\\n\\nNew algorithm: \\\"Dynamic Score with Item Size Penalty, Rest Capacity Bonus, and Exponential Decay with Adaptive Learning Rate\\\"\\n\\nDescription: This algorithm uses a dynamic score function that adaptively learns the weights of the item size penalty, rest capacity bonus, and exponential decay based on the usage history of the bins. The score function also includes a term that encourages the use of bins with lower utilization levels.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base score for each bin\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay factor based on bin usage history\\n decay_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n scores *= decay_factor\\n \\n # Use a dynamic learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.5\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Apply an item size penalty term\\n item_size_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= item_size_penalty\\n \\n # Apply a rest capacity bonus term\\n rest_capacity_bonus = np.abs(np.arange(len(bins)) - np.argmax(bins))\\n scores += rest_capacity_bonus\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization Factor with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the base scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a self-adaptive learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a term to encourage the use of bins with lower utilization levels\\n utilization_levels = np.divide(bins, bins.max())\\n scores += np.log(utilization_levels)\\n \\n # Apply an item size penalty term\\n item_size_penalty = np.abs(np.arange(len(bins)) - np.argmin(bins))\\n scores -= item_size_penalty\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"def score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a fixed learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to the scores\\n distance_penalty = 1 - np.exp(-np.abs(bins - item) / item)\\n scores -= distance_penalty\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a fixed learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n # Add a distance penalty term to the scores\\n distance_penalty = 1 - np.exp(-np.abs(bins - item) / 10)\\n scores -= distance_penalty\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Item Size-Based Score with Rest Capacity Bonus, Distance Penalty, and Bin Utilization with Exponential Decay and Self-Adaptive Learning Rate\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the initial scores\\n scores = bins / (bins - item) - np.arange(len(bins)) + bins\\n \\n # Apply exponential decay to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** np.arange(len(bins))\\n \\n # Use a fixed learning rate to adjust the weight of the utilization level in the score calculation\\n learning_rate = 0.1\\n scores += learning_rate * np.log(bins / bins.max())\\n \\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, aiming to evenly distribute the items and minimize the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space. Additionally, the algorithm incorporates a logarithmic function and a weighted factor to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items) - np.log2(bins)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. To promote performance and avoid utilizing the random component, I will implement the new algorithm using Numpy arrays and vectorized operations.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log2(remaining_capacity) * np.log10(num_assigned_items) + np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power penalty term that favors bins with lower capacities, promoting a more efficient use of space.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.power(remaining_capacity, 0.5) + np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account both the number of already assigned items to each bin and the exponential of the square root of the ratio between the bin's remaining capacity and the maximum capacity, with the goal of evenly distributing the items among bins and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n ratio = remaining_capacity / max_capacity\\n\\n scores = item / remaining_capacity + ratio * num_assigned_items + np.exp(-remaining_capacity / max_capacity) + np.cos(num_assigned_items) + np.exp(np.sqrt(ratio))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with higher capacities, promoting a more balanced distribution. Additionally, the algorithm incorporates a combination of exponential, logarithmic, and trigonometric functions to optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + remaining_capacity / np.max(bins) * num_assigned_items\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logarithmic transformation of the remaining capacity and item size to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log1p(remaining_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on their current capacity, the size of the item, and a penalty term that considers the number of already assigned items to each bin. \\n\\nNew algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more efficient use of space.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more equal distribution. Additionally, the algorithm incorporates a combination of exponential and hyperbolic functions to optimize the assignment, increasing the complexity and performance of the function.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.exp(-remaining_capacity) * np.tanh(num_assigned_items)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + 1 / np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items among bins and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = max_capacity - (bins - item)\\n\\n scores = item / (bins - item) + (bins - item) / max_capacity * num_assigned_items + np.sqrt(bins - item / max_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the remaining capacity of each bin, the size of the item, the number of assigned items, and a penalty term that favors bins with lower capacities, promoting a more efficient use of space while maintaining a balanced distribution.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.log(1 + remaining_capacity / np.max(bins))\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / np.max(bins)) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. Implement the algorithm using vectorized operations for improved performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(remaining_capacity) / np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logarithmic transformation of the remaining capacity and item size to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n assigned_items = np.max(bins) - remaining_capacities - 1\\n\\n scores = (item / remaining_capacities) + (remaining_capacities / np.max(bins)) * assigned_items + np.log1p(remaining_capacities) + np.cos(assigned_items)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with higher capacities, promoting a more balanced distribution. Additionally, the algorithm incorporates a combination of logarithmic and trigonometric functions to optimize the assignment, increasing the complexity and performance of the function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.log(remaining_capacity) * np.sin(num_assigned_items)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power-law penalty term that favors bins with lower capacities, promoting a more efficient use of space while ensuring a balanced distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = (remaining_capacity / max_capacity) ** 2\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to promote the utilization of larger capacity bins while still maintaining a balanced distribution of items. \\n\\nAlgorithm description:\\n1. Calculate the maximum capacity of the bins.\\n2. Calculate the remaining capacity of each bin after assigning the item.\\n3. Calculate the penalty term that favors bins with lower capacities.\\n4. Calculate the number of assigned items in each bin.\\n5. Calculate the scores for each bin based on a combination of the item size, remaining capacity, penalty term, and number of assigned items.\\n6. Return the scores for the bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.exp(-remaining_capacity / np.max(bins)) + np.sin(-num_assigned_items)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves assigning scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the objective of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more equal distribution. Additionally, the algorithm incorporates a combination of logarithmic and trigonometric functions to optimize the assignment, increasing the complexity and performance of the function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.log1p(remaining_capacity) * np.sin(num_assigned_items)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to promote the utilization of larger capacity bins while still maintaining a balanced distribution of items. \\n\\nAlgorithm description:\\n1. Calculate the maximum capacity of the bins.\\n2. Calculate the remaining capacity of each bin after assigning the item.\\n3. Calculate the penalty term that favors bins with lower capacities.\\n4. Calculate the number of assigned items in each bin.\\n5. Calculate the scores for each bin based on a combination of the item size, remaining capacity, penalty term, and number of assigned items.\\n6. Return the scores for the bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scaling_factor = 1 / np.sqrt(max_capacity) # Adjust the scaling factor as per your requirements\\n penalty_term = scaling_factor / np.sqrt(remaining_capacity)\\n\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.exp(-remaining_capacity / max_capacity) + np.sin(-num_assigned_items) + penalty_term\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm incorporates a combination of exponential, logarithmic, and trigonometric functions to assign scores to each bin based on the remaining capacity, item size, and a penalty term that favors bins with lower capacities, with the goal of achieving a balanced distribution and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.exp(-remaining_capacity / max_capacity) * np.log1p(num_assigned_items) + np.sin(num_assigned_items) - np.cos(remaining_capacity)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, aiming to evenly distribute the items and minimize the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space. Additionally, the algorithm incorporates a logarithmic function and a weighted factor to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items) - np.log2(bins)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. To promote performance and avoid utilizing the random component, I will implement the new algorithm using Numpy arrays and vectorized operations.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log2(remaining_capacity) * np.log10(num_assigned_items) + np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power penalty term that favors bins with lower capacities, promoting a more efficient use of space.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.power(remaining_capacity, 0.5) + np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account both the number of already assigned items to each bin and the exponential of the square root of the ratio between the bin's remaining capacity and the maximum capacity, with the goal of evenly distributing the items among bins and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n ratio = remaining_capacity / max_capacity\\n\\n scores = item / remaining_capacity + ratio * num_assigned_items + np.exp(-remaining_capacity / max_capacity) + np.cos(num_assigned_items) + np.exp(np.sqrt(ratio))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with higher capacities, promoting a more balanced distribution. Additionally, the algorithm incorporates a combination of exponential, logarithmic, and trigonometric functions to optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + remaining_capacity / np.max(bins) * num_assigned_items\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logarithmic transformation of the remaining capacity and item size to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log1p(remaining_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on their current capacity, the size of the item, and a penalty term that considers the number of already assigned items to each bin. \\n\\nNew algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more efficient use of space.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more equal distribution. Additionally, the algorithm incorporates a combination of exponential and hyperbolic functions to optimize the assignment, increasing the complexity and performance of the function.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.exp(-remaining_capacity) * np.tanh(num_assigned_items)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + 1 / np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items among bins and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = max_capacity - (bins - item)\\n\\n scores = item / (bins - item) + (bins - item) / max_capacity * num_assigned_items + np.sqrt(bins - item / max_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the remaining capacity of each bin, the size of the item, the number of assigned items, and a penalty term that favors bins with lower capacities, promoting a more efficient use of space while maintaining a balanced distribution.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.log(1 + remaining_capacity / np.max(bins))\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / np.max(bins)) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. Implement the algorithm using vectorized operations for improved performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(remaining_capacity) / np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logarithmic transformation of the remaining capacity and item size to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n assigned_items = np.max(bins) - remaining_capacities - 1\\n\\n scores = (item / remaining_capacities) + (remaining_capacities / np.max(bins)) * assigned_items + np.log1p(remaining_capacities) + np.cos(assigned_items)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms assign scores to bins based on the remaining capacity of each bin, the size of the item, and some penalty terms that consider the number of assigned items and the ratio of capacities.\\n\\nNew algorithm description: Assign scores to bins by combining the item size, the remaining capacity of each bin, a penalty term based on the difference between the maximum capacity and the remaining capacity, and a term that promotes a more balanced distribution of items among the bins. Implement the algorithm using efficient numpy operations for improved performance.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n ratio_capacity = remaining_capacity / np.max(bins)\\n\\n scores = item / remaining_capacity + ratio_capacity * num_assigned_items + (np.log(remaining_capacity) / np.log(np.max(bins))) * (1 - ratio_capacity)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power-law penalty term that favors bins with lower capacities, promoting a more efficient use of space while ensuring a balanced distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = (remaining_capacity / max_capacity) ** 2\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to promote the utilization of larger capacity bins while still maintaining a balanced distribution of items. \\n\\nAlgorithm description:\\n1. Calculate the maximum capacity of the bins.\\n2. Calculate the remaining capacity of each bin after assigning the item.\\n3. Calculate the penalty term that favors bins with lower capacities.\\n4. Calculate the number of assigned items in each bin.\\n5. Calculate the scores for each bin based on a combination of the item size, remaining capacity, penalty term, and number of assigned items.\\n6. Return the scores for the bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.exp(-remaining_capacity / np.max(bins)) + np.sin(-num_assigned_items)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves assigning scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the objective of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more equal distribution. Additionally, the algorithm incorporates a combination of logarithmic and trigonometric functions to optimize the assignment, increasing the complexity and performance of the function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.log1p(remaining_capacity) * np.sin(num_assigned_items)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, and the number of assigned items. It will also include a penalty term that penalizes bins with smaller capacities to encourage a more balanced distribution of items. To further promote efficient use of space, the penalty term will be modified to have an exponential decay with respect to the remaining capacity, and an additional term will be introduced to penalize bins with a large number of assigned items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.exp(-remaining_capacity / np.max(bins)) * np.log2(num_assigned_items) + np.exp(-num_assigned_items / np.max(bins))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm incorporates a combination of exponential, logarithmic, and trigonometric functions to assign scores to each bin based on the remaining capacity, item size, and a penalty term that favors bins with lower capacities, with the goal of achieving a balanced distribution and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.exp(-remaining_capacity / max_capacity) * np.log1p(num_assigned_items) + np.sin(num_assigned_items) - np.cos(remaining_capacity)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and penalty terms that favor certain properties of the bins.}\\n\\n## Algorithm Description:\\n{Assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, a logarithmic penalty term that favors bins with higher capacities, and a trigonometric penalty term that favors bins with lower capacities, promoting a balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity) + np.sin(np.pi * remaining_capacity / np.max(bins))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, aiming to evenly distribute the items and minimize the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space. Additionally, the algorithm incorporates a logarithmic function and a weighted factor to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items) - np.log2(bins)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. To promote performance and avoid utilizing the random component, I will implement the new algorithm using Numpy arrays and vectorized operations.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log2(remaining_capacity) * np.log10(num_assigned_items) + np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power penalty term that favors bins with lower capacities, promoting a more efficient use of space.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.power(remaining_capacity, 0.5) + np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account both the number of already assigned items to each bin and the exponential of the square root of the ratio between the bin's remaining capacity and the maximum capacity, with the goal of evenly distributing the items among bins and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n ratio = remaining_capacity / max_capacity\\n\\n scores = item / remaining_capacity + ratio * num_assigned_items + np.exp(-remaining_capacity / max_capacity) + np.cos(num_assigned_items) + np.exp(np.sqrt(ratio))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with higher capacities, promoting a more balanced distribution. Additionally, the algorithm incorporates a combination of exponential, logarithmic, and trigonometric functions to optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + remaining_capacity / np.max(bins) * num_assigned_items\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic term that favors bins with lower capacities, promoting a more balanced distribution and efficient use of space.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(1/(remaining_capacity+1)) / np.log(np.max(bins)+1)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of the bin's remaining capacity, the item size, and the number of assigned items.\\n\\nNew algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a hyperbolic function that favors bins with lower capacities, promoting a more equal distribution and efficient use of space.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / np.max(bins)) * num_assigned_items + np.tanh(remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more equal distribution. Additionally, the algorithm incorporates a combination of exponential and hyperbolic functions to optimize the assignment, increasing the complexity and performance of the function.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = np.exp(-remaining_capacity) * np.tanh(num_assigned_items)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin and the logarithm of the remaining capacity, with the goal of promoting a balanced distribution and minimizing the number of used bins without compromising the utilization of larger capacity bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items among bins and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = max_capacity - (bins - item)\\n\\n scores = item / (bins - item) + (bins - item) / max_capacity * num_assigned_items + np.sqrt(bins - item / max_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of already assigned items, and a hyperbolic penalty term that favors bins with higher capacities, promoting a more balanced distribution of items while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.tanh(remaining_capacity)\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items - penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on the combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. Implement the algorithm using vectorized operations for improved performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(remaining_capacity) / np.log(np.max(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logarithmic transformation of the remaining capacity and item size to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n assigned_items = np.max(bins) - remaining_capacities - 1\\n\\n scores = (item / remaining_capacities) + (remaining_capacities / np.max(bins)) * assigned_items + np.log1p(remaining_capacities) + np.cos(assigned_items)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, and the number of assigned items, and incorporates a penalty term that penalizes bins with a large number of assigned items and a linear transformation of the remaining capacity to optimize the assignment while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + 2 * np.sin(remaining_capacity / np.max(bins)) + 3 * np.sqrt(num_assigned_items / np.max(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power-law penalty term that favors bins with lower capacities, promoting a more efficient use of space while ensuring a balanced distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = (remaining_capacity / max_capacity) ** 2\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to promote the utilization of larger capacity bins while still maintaining a balanced distribution of items. \\n\\nAlgorithm description:\\n1. Calculate the maximum capacity of the bins.\\n2. Calculate the remaining capacity of each bin after assigning the item.\\n3. Calculate the penalty term that favors bins with lower capacities.\\n4. Calculate the number of assigned items in each bin.\\n5. Calculate the scores for each bin based on a combination of the item size, remaining capacity, penalty term, and number of assigned items.\\n6. Return the scores for the bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_assigned_items = np.max(bins) - (bins - item)\\n\\n scores = item / (bins - item) + ((bins - item) / np.max(bins)) * num_assigned_items + np.exp(-(bins - item) / np.max(bins)) + np.sin(-num_assigned_items)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that penalizes bins with higher capacities and promotes a more balanced distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = -1 * np.log(remaining_capacity / max_capacity)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, and the number of assigned items. It will also include a penalty term that penalizes bins with smaller capacities to encourage a more balanced distribution of items. To further promote efficient use of space, the penalty term will be modified to have an exponential decay with respect to the remaining capacity, and an additional term will be introduced to penalize bins with a large number of assigned items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.exp(-remaining_capacity / np.max(bins)) * np.log2(num_assigned_items) + np.exp(-num_assigned_items / np.max(bins))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and penalty terms that favor certain properties of the bins.}\\n\\n## Algorithm Description:\\n{Assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, a logarithmic penalty term that favors bins with higher capacities, and a trigonometric penalty term that favors bins with lower capacities, promoting a balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity) + np.sin(np.pi * remaining_capacity / np.max(bins))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, aiming to evenly distribute the items and minimize the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space. Additionally, the algorithm incorporates a logarithmic function and a weighted factor to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items) - np.log2(bins)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. To promote performance and avoid utilizing the random component, I will implement the new algorithm using Numpy arrays and vectorized operations.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log2(remaining_capacity) * np.log10(num_assigned_items) + np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power penalty term that favors bins with lower capacities, promoting a more efficient use of space.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.power(remaining_capacity, 0.5) + np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logistic transformation of the remaining capacity and item size, as well as a sine function of the assigned items, to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n assigned_items = np.max(bins) - remaining_capacities - 1\\n\\n scores = (item / remaining_capacities) + (remaining_capacities / np.max(bins)) * assigned_items + np.log(remaining_capacities + 1) + np.sin(assigned_items)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with higher capacities, promoting a more balanced distribution. Additionally, the algorithm incorporates a combination of exponential, logarithmic, and trigonometric functions to optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + remaining_capacity / np.max(bins) * num_assigned_items\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of the bin's remaining capacity, the item size, and the number of assigned items.\\n\\nNew algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, and a hyperbolic tangent function that promotes a more equal distribution and efficient use of space, while also incorporating a logarithmic penalty term that favors bins with higher capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.tanh(remaining_capacity) + np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.tanh(remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the common backbone idea in the provided algorithms, the new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with higher capacities, promoting a balanced distribution and efficient use of space.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(remaining_capacity) + np.log(num_assigned_items)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin and the logarithm of the remaining capacity, with the goal of promoting a balanced distribution and minimizing the number of used bins without compromising the utilization of larger capacity bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items among bins and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = max_capacity - (bins - item)\\n\\n scores = item / (bins - item) + (bins - item) / max_capacity * num_assigned_items + np.sqrt(bins - item / max_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of already assigned items, and a hyperbolic penalty term that favors bins with higher capacities, promoting a more balanced distribution of items while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.tanh(remaining_capacity)\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items - penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = (item * remaining_capacity * num_assigned_items) * (1 / np.log(1 + remaining_capacity))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logarithmic transformation of the remaining capacity and item size to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n assigned_items = np.max(bins) - remaining_capacities - 1\\n\\n scores = (item / remaining_capacities) + (remaining_capacities / np.max(bins)) * assigned_items + np.log1p(remaining_capacities) + np.cos(assigned_items)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, and the number of assigned items, and incorporates a penalty term that penalizes bins with a large number of assigned items and a linear transformation of the remaining capacity to optimize the assignment while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + 2 * np.sin(remaining_capacity / np.max(bins)) + 3 * np.sqrt(num_assigned_items / np.max(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, and the number of assigned items. It will also include a penalty term that penalizes bins with smaller capacities to encourage a more balanced distribution of items. To further promote efficient use of space, the penalty term will be modified to have an exponential decay with respect to the remaining capacity, and an additional term will be introduced to penalize bins with a large number of assigned items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + remaining_capacity / np.max(bins) * num_assigned_items + num_assigned_items / np.max(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to promote the utilization of larger capacity bins while still maintaining a balanced distribution of items. \\n\\nAlgorithm description:\\n1. Calculate the maximum capacity of the bins.\\n2. Calculate the remaining capacity of each bin after assigning the item.\\n3. Calculate the penalty term that favors bins with lower capacities.\\n4. Calculate the number of assigned items in each bin.\\n5. Calculate the scores for each bin based on a combination of the item size, remaining capacity, penalty term, and number of assigned items.\\n6. Return the scores for the bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_assigned_items = np.max(bins) - (bins - item)\\n\\n scores = item / (bins - item) + ((bins - item) / np.max(bins)) * num_assigned_items + np.exp(-(bins - item) / np.max(bins)) + np.sin(-num_assigned_items)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that penalizes bins with higher capacities and promotes a more balanced distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = -1 * np.log(remaining_capacity / max_capacity)\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, and the number of assigned items. It will also include a penalty term that penalizes bins with smaller capacities to encourage a more balanced distribution of items. To further promote efficient use of space, the penalty term will be modified to have an exponential decay with respect to the remaining capacity, and an additional term will be introduced to penalize bins with a large number of assigned items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = np.max(bins)\\n scores = item / (bins - item) + ((bins - item) / scaling_factor) * (np.max(bins) - (bins - item)) + np.exp(-(bins - item) / scaling_factor) * np.log2((np.max(bins) - (bins - item))) + np.exp(-((np.max(bins) - (bins - item)) / scaling_factor))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins.max() - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximize Rest Capacity\\\" (MRCA). It assigns an item to the bin with the maximum rest capacity, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\\n\\nHere is the implementation of the MRCA algorithm in Python:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the maximum rest capacity for each bin\\n max_rest_capacities = np.max(bins - item)\\n # Assign the item to the bin with the maximum rest capacity\\n max_rest_capacity_index = np.argmax(max_rest_capacities)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the maximum rest capacity to 0\\n scores[max_rest_capacity_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The algorithms assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items already assigned to each bin.\\n\\nDescription: The algorithm calculates the distance between the item size and the bin capacity for each bin, and then assigns the item to the bin with the minimum distance. The score for each bin is calculated as the inverse of the distance between the item size and the bin capacity, and is further adjusted based on the number of items already assigned to the bin, and the number of items already assigned to each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Assign the item to the bin with the minimum distance\\n min_distance_index = np.argmin(distances)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins == np.max(bins)))\\n # Set the score for the bin with the minimum distance to 0\\n scores[min_distance_index] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Maximizing the minimum score.\\nNew algorithm: \\\"Minimize the maximum score\\\".\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Assign the item to the bin with the minimum score\\n min_score_index = np.argmin(distances)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum score to 0\\n scores[min_score_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins >= item, 0, np.clip(bins / item, 0, None))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the minimum score\\\"\\n\\nMain steps:\\n\\n1. Calculate the ratio of rest capacity of each bin to the item size.\\n2. Set the score for bins with equal rest capacity to the maximum capacity as 0.\\n3. Calculate the scores for each bin by multiplying the ratios with the inverse of the bin index (i.e., 1/index).\\n4. Return the scores.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with the inverse of the bin index\\n scores = ratios * (1 / np.arange(1, len(bins)+1))\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the number of items already assigned to each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the sum of the squares of the ratios between the item sizes and the rest capacities of the bins, while also considering the number of empty bins and the standard deviation of the remaining bins' capacities.\\\"\\n\\nPython function:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by squaring the ratios\\n scores = ratios ** 2\\n \\n # Maximize the sum of the scores by assigning the item to the bin with the largest ratio\\n max_ratio_index = np.argmax(ratios)\\n scores[max_ratio_index] = 0\\n \\n # Consider the number of empty bins and the standard deviation of the remaining bins' capacities\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n std_capacity = np.std(bins)\\n scores -= (num_empty_bins + 1) * (std_capacity / item)\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n \\n return scores\",\n \"objective\": 0.0489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the number of empty bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n scores = np.zeros_like(bins)\\n scores[bins > item] = (num_empty_bins + 1) / (bins[bins > item] / item)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the number of empty bins, and the standard deviation of the remaining bins to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the number of empty bins\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n # Calculate the standard deviation of the remaining bins\\n std_dev = np.std(bins[bins > item])\\n # Calculate the score for each bin\\n scores = np.zeros_like(bins)\\n scores[bins > item] = (num_empty_bins + 1) / (std_dev / item)\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin, with a focus on minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.05121,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the ratio of the item size to the rest capacity of each bin while minimizing the number of used bins.\\\"\\n\\nPython function:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n # Minimize the number of used bins by assigning the item to the bin with the highest score\\n min_score_index = np.argmax(scores)\\n \\n # Set the score for the bin with the highest score to 0\\n scores[min_score_index] = 0\\n \\n return scores\",\n \"objective\": 0.05161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the number of empty bins, and the standard deviation of the remaining bins' capacities to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n std_capacity = np.std(bins)\\n scores = np.zeros_like(bins)\\n scores[bins > item] = (num_empty_bins + 1) * (std_capacity / item)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to minimize the number of used bins by calculating a score for each bin based on its capacity and the item size.\\n\\nNew algorithm: \\\"Minimize the number of used bins by assigning items to bins with the closest capacity ratio to the item size, while also considering the number of empty bins and the standard deviation of the remaining bins' capacities.\\\"\\n\\nPython function:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n # Minimize the number of used bins by assigning the item to the bin with the closest capacity ratio to the item size\\n min_ratio_index = np.argmin(np.abs(ratios - 1))\\n scores[min_ratio_index] = 0\\n \\n # Consider the number of empty bins and the standard deviation of the remaining bins' capacities\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n std_capacity = np.std(bins)\\n scores += (num_empty_bins + 1) * (std_capacity / item)\\n \\n return scores\",\n \"objective\": 0.05393,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and penalty terms that favor certain properties of the bins.}\\n\\n## Algorithm Description:\\n{Assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, a logarithmic penalty term that favors bins with higher capacities, and a trigonometric penalty term that favors bins with lower capacities, promoting a balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity) + np.sin(np.pi * remaining_capacity / np.max(bins))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, aiming to evenly distribute the items and minimize the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space. Additionally, the algorithm incorporates a logarithmic function and a weighted factor to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items) - np.log2(bins)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with higher capacities, promoting a more balanced distribution and efficient use of space. To promote performance and avoid utilizing the random component, I will implement the new algorithm using Numpy arrays and vectorized operations.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log10(remaining_capacity) * np.log2(num_assigned_items) - np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a more balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log2(remaining_capacity) * np.log10(num_assigned_items) + np.exp(-np.max(bins) / remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a power penalty term that favors bins with lower capacities, promoting a more efficient use of space.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / max_capacity) * num_assigned_items + np.power(remaining_capacity, 0.5) + np.sqrt(num_assigned_items)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and a penalty term that takes into account the number of already assigned items to each bin, with the aim of achieving a balanced distribution of items while minimizing the number of used bins. The algorithm also incorporates a logistic transformation of the remaining capacity and item size, as well as a sine function of the assigned items, to further optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n assigned_items = np.max(bins) - remaining_capacities - 1\\n\\n scores = (item / remaining_capacities) + (remaining_capacities / np.max(bins)) * assigned_items + np.log(remaining_capacities + 1) + np.sin(assigned_items)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items and minimizing the number of used bins. The penalty term is adjusted to favor bins with higher capacities, promoting a more balanced distribution. Additionally, the algorithm incorporates a combination of exponential, logarithmic, and trigonometric functions to optimize the assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + remaining_capacity / np.max(bins) * num_assigned_items\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of the bin's remaining capacity, the item size, and the number of assigned items.\\n\\nNew algorithm description: Assign scores to bins based on a combination of the bin's remaining capacity, the item size, and a hyperbolic tangent function that promotes a more equal distribution and efficient use of space, while also incorporating a logarithmic penalty term that favors bins with higher capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.tanh(remaining_capacity) + np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.tanh(remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a penalty term that promotes a balanced distribution and minimizes the number of used bins.\\n\\nNew algorithm description: My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of already assigned items, and an exponential penalty term that favors bins with lower capacities, promoting a more balanced distribution and efficient use of space while minimizing the number of used bins.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.exp(-remaining_capacity)\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin and the logarithm of the remaining capacity, with the goal of promoting a balanced distribution and minimizing the number of used bins without compromising the utilization of larger capacity bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.log(remaining_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their current capacity, the size of the item, and a penalty term that takes into account the number of already assigned items to each bin, with the goal of evenly distributing the items among bins and minimizing the number of used bins. The penalty term is adjusted to favor bins with lower capacities, promoting a more efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = max_capacity - (bins - item)\\n\\n scores = item / (bins - item) + (bins - item) / max_capacity * num_assigned_items + np.sqrt(bins - item / max_capacity) + np.cos(num_assigned_items)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of already assigned items, and a hyperbolic penalty term that favors bins with higher capacities, promoting a more balanced distribution of items while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.tanh(remaining_capacity)\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items - penalty\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the bin's remaining capacity, the item size, the number of assigned items, and a logarithmic penalty term that favors bins with lower capacities, promoting a balanced distribution and efficient use of space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = (item * remaining_capacity * num_assigned_items) * (1 / np.log(1 + remaining_capacity))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a penalty term that promotes a balanced distribution. It also incorporates a power function to further penalize bins with higher capacities and encourages the use of larger capacity bins for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.power(remaining_capacity, -0.5)\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items - penalty\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the item size, the number of assigned items, and a modified penalty term that penalizes bins with higher capacities. The modified penalty term will be the reciprocal of the remaining capacity, which ensures that bins with lower capacity receive a higher penalty and encourages a more balanced distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = max_capacity - remaining_capacity\\n\\n penalty = 1 / remaining_capacity\\n\\n scores = (item / remaining_capacity) + (remaining_capacity / max_capacity) * num_assigned_items + penalty\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will assign scores to bins based on the bin's remaining capacity, the item size, and the number of assigned items. It will also include a penalty term that penalizes bins with smaller capacities to encourage a more balanced distribution of items. To further promote efficient use of space, the penalty term will be modified to have an exponential decay with respect to the remaining capacity, and an additional term will be introduced to penalize bins with a large number of assigned items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (bins - item) + (bins - item) / np.max(bins) * (np.max(bins) - (bins - item)) + (np.max(bins) - (bins - item)) / np.max(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to promote the utilization of larger capacity bins while still maintaining a balanced distribution of items. \\n\\nAlgorithm description:\\n1. Calculate the maximum capacity of the bins.\\n2. Calculate the remaining capacity of each bin after assigning the item.\\n3. Calculate the penalty term that favors bins with lower capacities.\\n4. Calculate the number of assigned items in each bin.\\n5. Calculate the scores for each bin based on a combination of the item size, remaining capacity, penalty term, and number of assigned items.\\n6. Return the scores for the bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_assigned_items = np.max(bins) - (bins - item)\\n\\n scores = item / (bins - item) + ((bins - item) / np.max(bins)) * num_assigned_items + np.exp(-(bins - item) / np.max(bins)) + np.sin(-num_assigned_items)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of already assigned items, and a trigonometric penalty term that favors bins with higher capacities, promoting a balanced distribution and efficient use of space, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items + np.sin(remaining_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, the number of already assigned items, and a logarithmic penalty term, creating a balance between capacity utilization and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n num_assigned_items = np.max(bins) - remaining_capacity\\n\\n penalty = np.log(remaining_capacity + 1)\\n\\n scores = item / remaining_capacity + (remaining_capacity / np.max(bins)) * num_assigned_items - penalty\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins.max() - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as the inverse of its capacity\\n scores = 1 / bins\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= distances / bins\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already in the bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by considering the distance between the item size and the bin capacity, and the number of items already in the bin, while also using a penalty term for bins with high standard deviation of the remaining bins' capacities, and adjusting the score based on the number of items already assigned to each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, and also using a penalty term for bins with high standard deviation of the remaining bins' capacities, and adjusting the score based on the number of items already assigned to each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the number of items already in each bin\\n num_items = np.count_nonzero(bins)\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Calculate the penalty term for bins with high standard deviation of the remaining bins' capacities\\n penalty = std_capacity / item\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, and adding the penalty term\\n scores = (1 / distances) * (len(bins) - num_items) + penalty\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(num_items)\\n # Assign the item to the bin with the lowest score\\n min_score_index = np.argmin(scores)\\n # Set the score for the bin with the lowest score to 0\\n scores[min_score_index] = 0\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Minimize Wasted Space\\\" (MWS), assigns an item to the bin with the minimum wasted space, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the minimum wasted space for each bin\\n min_wasted_spaces = np.min(bins - item)\\n # Assign the item to the bin with the minimum wasted space\\n min_wasted_space_index = np.argmin(min_wasted_spaces)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum wasted space to 0\\n scores[min_wasted_space_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by prioritizing the distance between the item size and the bin capacity, and the number of items already assigned to each bin, while also considering the number of items that can fit in each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items that can fit in each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items that can fit in each bin\\n scores -= np.log(np.sum(bins > item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Maximizing the minimum score.\\nNew algorithm: \\\"Maximize the minimum score with a twist\\\".\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to maximize the minimum score, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, but with a twist: instead of assigning the item to the bin with the minimum score directly, it first calculates the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, and then assigns the item to the bin with the highest score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Assign the item to the bin with the highest score\\n max_score_index = np.argmax(scores)\\n # Set the score for the bin with the highest score to 0\\n scores[max_score_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins >= item, 0, np.clip(bins / item, 0, None))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimize the maximum score\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the number of items already assigned to each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the number of used bins by considering the distance between the item size and the bin capacity, and the number of items already in the bin, while also using a reward term for bins with low standard deviation of the remaining bins' capacities, and adjusting the score based on the number of items already assigned to each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the highest score, considering the rest capacity of each bin, in order to maximize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, and also using a reward term for bins with low standard deviation of the remaining bins' capacities, and adjusting the score based on the number of items already assigned to each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the number of items already in each bin\\n num_items = np.count_nonzero(bins)\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Calculate the reward term for bins with low standard deviation of the remaining bins' capacities\\n reward = std_capacity / item\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, and adding the reward term\\n scores = (1 / distances) * (len(bins) - num_items) + reward\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.log(num_items)\\n # Assign the item to the bin with the highest score\\n max_score_index = np.argmax(scores)\\n # Set the score for the bin with the highest score to 0\\n scores[max_score_index] = 0\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the sum of the squares of the ratios between the item sizes and the rest capacities of the bins, while also considering the number of empty bins and the standard deviation of the remaining bins' capacities.\\\"\\n\\nPython function:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by squaring the ratios\\n scores = ratios ** 2\\n \\n # Maximize the sum of the scores by assigning the item to the bin with the largest ratio\\n max_ratio_index = np.argmax(ratios)\\n scores[max_ratio_index] = 0\\n \\n # Consider the number of empty bins and the standard deviation of the remaining bins' capacities\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n std_capacity = np.std(bins)\\n scores -= (num_empty_bins + 1) * (std_capacity / item)\\n \\n return scores\",\n \"objective\": 0.04729,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Minimize the number of used bins by considering the distance between the item size and the bin capacity, the number of items already in the bin, and the standard deviation of the remaining bins' capacities, while also using a penalty term for bins with high standard deviation of the remaining bins' capacities and a bonus term for bins with low standard deviation of the remaining bins' capacities.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, the number of items already in the bin, the standard deviation of the remaining bins' capacities, and a penalty term for bins with high standard deviation of the remaining bins' capacities and a bonus term for bins with low standard deviation of the remaining bins' capacities.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the number of items already in each bin\\n num_items = np.count_nonzero(bins)\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Calculate the penalty term for bins with high standard deviation of the remaining bins' capacities\\n penalty = std_capacity / item\\n # Calculate the bonus term for bins with low standard deviation of the remaining bins' capacities\\n bonus = (1 - std_capacity) / item\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, adding the penalty term, and subtracting the bonus term\\n scores = (1 / distances) * (len(bins) - num_items) + penalty - bonus\\n # Assign the item to the bin with the lowest score\\n min_score_index = np.argmin(scores)\\n # Set the score for the bin with the lowest score to 0\\n scores[min_score_index] = 0\\n return scores\",\n \"objective\": 0.04799,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximize the number of used bins by considering the distance between the item size and the bin capacity, and the number of items already in the bin, while also using a reward term for bins with low standard deviation of the remaining bins' capacities.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the highest score, considering the rest capacity of each bin, in order to maximize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, and also using a reward term for bins with low standard deviation of the remaining bins' capacities.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the number of items already in each bin\\n num_items = np.count_nonzero(bins)\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Calculate the reward term for bins with low standard deviation of the remaining bins' capacities\\n reward = std_capacity / item\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, and adding the reward term\\n scores = (1 / distances) * (len(bins) - num_items) + reward\\n # Assign the item to the bin with the highest score\\n max_score_index = np.argmax(scores)\\n # Set the score for the bin with the highest score to 0\\n scores[max_score_index] = 0\\n return scores\",\n \"objective\": 0.04829,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= np.sqrt(distances)\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already in the bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by considering the distance between the item size and the bin capacity, and the number of items already in the bin, while also using a penalty term for bins with high standard deviation of the remaining bins' capacities.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the lowest score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, and also using a penalty term for bins with high standard deviation of the remaining bins' capacities.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the number of items already in each bin\\n num_items = np.count_nonzero(bins)\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Calculate the penalty term for bins with high standard deviation of the remaining bins' capacities\\n penalty = std_capacity / item\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, and subtracting the penalty term\\n scores = (1 / distances) * (len(bins) - num_items) - penalty\\n # Assign the item to the bin with the lowest score\\n min_score_index = np.argmin(scores)\\n # Set the score for the bin with the lowest score to 0\\n scores[min_score_index] = 0\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Minimize Wasted Space\\\" (MWS), assigns an item to the bin with the minimum wasted space, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the minimum wasted space for each bin\\n min_wasted_spaces = np.min(bins - item)\\n # Assign the item to the bin with the minimum wasted space\\n min_wasted_space_index = np.argmin(min_wasted_spaces)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum wasted space to 0\\n scores[min_wasted_space_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by prioritizing the distance between the item size and the bin capacity, and the number of items already assigned to each bin, while also considering the number of items that can fit in each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items that can fit in each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items that can fit in each bin\\n scores -= np.log(np.sum(bins > item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins.\\nNew algorithm: \\\"Maximize the number of items in each bin while minimizing the number of used bins\\\".\\n\\nDescription: The algorithm assigns an item to the bin with the highest score, considering the rest capacity of each bin, in order to maximize the number of items in each bin, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, but with a twist: instead of assigning the item to the bin with the highest score directly, it first calculates the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity, and then assigns the item to the bin with the highest score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity\\n scores = (len(bins) - np.count_nonzero(bins)) / distances\\n # Assign the item to the bin with the highest score\\n max_score_index = np.argmax(scores)\\n # Set the score for the bin with the highest score to 0\\n scores[max_score_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Binning with Optimal Fit\\\" (BOF)\\nBOF assigns an item to the bin with the optimal fit based on the item size and the rest capacity of each bin, while also considering the number of items already in the bin and the standard deviation of the remaining bins' capacities.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * std_capacity\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimize the maximum score\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / bins[bins != bins.max()])\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximize the sum of the squares of the ratios between the item sizes and the rest capacities of the bins, while also considering the number of empty bins and the standard deviation of the remaining bins' capacities, and also using a penalty term for bins with high standard deviation of the remaining bins' capacities and a bonus term for bins with low standard deviation of the remaining bins' capacities, and also considering the number of items already assigned to each bin.\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity of each bin\\n ratios = item / bins\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by squaring the ratios\\n scores = ratios ** 2\\n \\n # Maximize the sum of the scores by assigning the item to the bin with the largest ratio\\n max_ratio_index = np.argmax(ratios)\\n scores[max_ratio_index] = 0\\n \\n # Consider the number of empty bins and the standard deviation of the remaining bins' capacities\\n num_empty_bins = np.count_nonzero(bins == np.max(bins))\\n std_capacity = np.std(bins)\\n scores -= (num_empty_bins + 1) * (std_capacity / item)\\n \\n # Use a penalty term for bins with high standard deviation of the remaining bins' capacities\\n penalty = std_capacity / item\\n scores += penalty\\n \\n # Use a bonus term for bins with low standard deviation of the remaining bins' capacities\\n bonus = (1 - std_capacity) / item\\n scores -= bonus\\n \\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size, the rest capacity of each bin, and the number of items already assigned to each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.log(np.sum(bins <= item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, the number of items already in the bin, and the standard deviation of the remaining bins' capacities.\\n\\nNew algorithm: \\\"Minimize the number of used bins by considering the distance between the item size and the bin capacity, the number of items already in the bin, and the standard deviation of the remaining bins' capacities, while also using a penalty term for bins with high standard deviation of the remaining bins' capacities and a bonus term for bins with low standard deviation of the remaining bins' capacities, and also considering the number of items already assigned to each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, the number of items already in the bin, the standard deviation of the remaining bins' capacities, and a penalty term for bins with high standard deviation of the remaining bins' capacities and a bonus term for bins with low standard deviation of the remaining bins' capacities, and also considering the number of items already assigned to each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the number of items already in each bin\\n num_items = np.count_nonzero(bins)\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Calculate the penalty term for bins with high standard deviation of the remaining bins' capacities\\n penalty = std_capacity / item\\n # Calculate the bonus term for bins with low standard deviation of the remaining bins' capacities\\n bonus = (1 - std_capacity) / item\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, adding the penalty term, and subtracting the bonus term\\n scores = (1 / distances) * (len(bins) - num_items) + penalty - bonus\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the lowest score to 0\\n scores[np.argmin(scores)] = 0\\n return scores\",\n \"objective\": 0.04598,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Balanced Distribution\\\" (BALD), assigns an item to the bin with the balanced distribution of the item sizes and the rest capacities of the bins, while also considering the number of items already in the bin and the standard deviation of the remaining bins' capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the balance score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n balance_scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the balance score based on the standard deviation of the remaining bins' capacities\\n balance_scores += 0.1 * std_capacity\\n # Calculate the score for each bin as the inverse of the balance score\\n scores = 1 / balance_scores\\n # Set the score for the bin with the optimal balance to 0\\n scores[np.argmin(balance_scores)] = 0\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Maximum Spread\\\" (MS), assigns an item to the bin with the maximum spread of item sizes, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the spread of item sizes for each bin\\n spreads = np.var(bins)\\n # Assign the item to the bin with the maximum spread of item sizes\\n max_spread_index = np.argmax(spreads)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the spread of item sizes\\n scores = (1 / distances) * spreads\\n # Set the score for the bin with the maximum spread of item sizes to 0\\n scores[max_spread_index] = 0\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as 0\\n scores = np.zeros_like(bins)\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = bins - item\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.sum(bins <= item)\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Bin Size Penalty\\\". It penalizes bins based on their sizes to encourage using smaller bins first.\\n\\nHere is the implementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Add a penalty term based on the size of the bin\\n penalty = (bins - min(bins)) / (max(bins) - min(bins))\\n scores += penalty\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the standard deviation of the remaining bins' capacities to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n \\n # Calculate the score based on the item's size, the distance, and the standard deviation\\n scores = np.log(item / distances) + np.log(distances / std_capacity)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm uses a combination of the item size, the number of items already in the bin, and the standard deviation of the remaining bins' capacities to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the number of items already in each bin\\n num_items = np.count_nonzero(bins)\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin, and subtracting the standard deviation of the remaining bins' capacities\\n scores = (1 / distances) * (len(bins) - num_items) - std_capacity\\n # Set the score for the bin with the lowest score to 0\\n min_score_index = np.argmin(scores)\\n scores[min_score_index] = 0\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Minimize Wasted Space\\\" (MWS), assigns an item to the bin with the minimum wasted space, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the minimum wasted space for each bin\\n min_wasted_spaces = np.min(bins - item)\\n # Assign the item to the bin with the minimum wasted space\\n min_wasted_space_index = np.argmin(min_wasted_spaces)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum wasted space to 0\\n scores[min_wasted_space_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Bin Packing with Adaptive Scoring and Item Size Weighting (BPAS-ISW)\\n\\nMain steps:\\n\\n1. Initialize the scores for each bin as a constant value.\\n2. Calculate the absolute difference between the item size and the bin capacity for each bin.\\n3. Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size.\\n4. Adjust the score based on the number of items already assigned to each bin.\\n5. Adjust the score based on the total capacity of the bins.\\n6. Set the score for the bin with the minimum distance to 0.\\n7. Adapt the score based on the number of items already in the bin.\\n8. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Adjust the score based on the total capacity of the bins\\n scores += 0.1 * np.log(np.sum(bins))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n # Adapt the score based on the number of items already in the bin\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by prioritizing the distance between the item size and the bin capacity, and the number of items already assigned to each bin, while also considering the number of items that can fit in each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items that can fit in each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items that can fit in each bin\\n scores -= np.log(np.sum(bins > item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins.\\nNew algorithm: \\\"Maximize the number of items in each bin while minimizing the number of used bins\\\".\\n\\nDescription: The algorithm assigns an item to the bin with the highest score, considering the rest capacity of each bin, in order to maximize the number of items in each bin, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, but with a twist: instead of assigning the item to the bin with the highest score directly, it first calculates the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity, and then assigns the item to the bin with the highest score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity\\n scores = (len(bins) - np.count_nonzero(bins)) / distances\\n # Assign the item to the bin with the highest score\\n max_score_index = np.argmax(scores)\\n # Set the score for the bin with the highest score to 0\\n scores[max_score_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Binning with Optimal Fit\\\" (BOF)\\nBOF assigns an item to the bin with the optimal fit based on the item size and the rest capacity of each bin, while also considering the number of items already in the bin and the standard deviation of the remaining bins' capacities.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * std_capacity\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins >= item, 1, 0)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Binning with Optimal Fit and Standard Deviation\\\" (BOFD)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * std_capacity\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n # Calculate the standard deviation of the scores\\n std_scores = np.std(scores)\\n # Adjust the score based on the standard deviation of the scores\\n scores += 0.1 * std_scores\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimize the maximum score\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Maximum Spread\\\" (MS), assigns an item to the bin with the maximum spread of item sizes, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the spread of item sizes for each bin\\n spreads = np.var(bins)\\n # Assign the item to the bin with the maximum spread of item sizes\\n max_spread_index = np.argmax(spreads)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the spread of item sizes\\n scores = (1 / distances) * spreads\\n # Set the score for the bin with the maximum spread of item sizes to 0\\n scores[max_spread_index] = 0\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as 0\\n scores = np.zeros_like(bins)\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = bins - item\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.sum(bins <= item)\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is called \\\"Maximum Score with Item Size Bonus\\\". It rewards bins based on their sizes to encourage using larger bins when possible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Add a bonus term based on the size of the bin\\n bonus = (bins - min(bins)) / (max(bins) - min(bins))\\n scores += bonus\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the standard deviation of the remaining bins' capacities to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n \\n # Calculate the score based on the item's size, the distance, and the standard deviation\\n scores = np.log(item / distances) + np.log(distances / std_capacity)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Bin Packing with Adaptive Scoring and Item Size Weighting (BPAS-ISW)\\n\\nMain steps:\\n\\n1. Initialize the scores for each bin as a constant value.\\n2. Calculate the absolute difference between the item size and the bin capacity for each bin.\\n3. Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size.\\n4. Adjust the score based on the number of items already assigned to each bin.\\n5. Adjust the score based on the total capacity of the bins.\\n6. Set the score for the bin with the minimum distance to 0.\\n7. Adapt the score based on the number of items already in the bin.\\n8. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the Euclidean distance between the item size and the bin capacity for each bin\\n distances = np.sqrt((bins - item)**2)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Set the score for the bin with the minimum distance to a small negative value\\n scores[np.argmin(distances)] = -0.1\\n # Adapt the score based on the number of items already in the bin, but only for bins with a similar size to the current item\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Minimize Wasted Space\\\" (MWS), assigns an item to the bin with the minimum wasted space, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the minimum wasted space for each bin\\n min_wasted_spaces = np.min(bins - item)\\n # Assign the item to the bin with the minimum wasted space\\n min_wasted_space_index = np.argmin(min_wasted_spaces)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum wasted space to 0\\n scores[min_wasted_space_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Bin Packing with Adaptive Scoring and Item Size Weighting (BPAS-ISW)\\n\\nMain steps:\\n\\n1. Initialize the scores for each bin as a constant value.\\n2. Calculate the absolute difference between the item size and the bin capacity for each bin.\\n3. Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size.\\n4. Adjust the score based on the number of items already assigned to each bin.\\n5. Adjust the score based on the total capacity of the bins.\\n6. Set the score for the bin with the minimum distance to 0.\\n7. Adapt the score based on the number of items already in the bin.\\n8. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Adjust the score based on the total capacity of the bins\\n scores += 0.1 * np.log(np.sum(bins))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n # Adapt the score based on the number of items already in the bin\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by prioritizing the distance between the item size and the bin capacity, and the number of items already assigned to each bin, while also considering the number of items that can fit in each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items that can fit in each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items that can fit in each bin\\n scores -= np.log(np.sum(bins > item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins.\\nNew algorithm: \\\"Maximize the number of items in each bin while minimizing the number of used bins\\\".\\n\\nDescription: The algorithm assigns an item to the bin with the highest score, considering the rest capacity of each bin, in order to maximize the number of items in each bin, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, but with a twist: instead of assigning the item to the bin with the highest score directly, it first calculates the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity, and then assigns the item to the bin with the highest score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity\\n scores = (len(bins) - np.count_nonzero(bins)) / distances\\n # Assign the item to the bin with the highest score\\n max_score_index = np.argmax(scores)\\n # Set the score for the bin with the highest score to 0\\n scores[max_score_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Binning with Optimal Fit\\\" (BOF)\\nBOF assigns an item to the bin with the optimal fit based on the item size and the rest capacity of each bin, while also considering the number of items already in the bin and the standard deviation of the remaining bins' capacities.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * std_capacity\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / sum(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the best fit or the least waste of space.\\n\\nNew algorithm: \\\"Maximize Bin Utilization\\\" (MBU)\\nMBU assigns an item to the bin with the highest potential utilization, considering the item size, the bin capacity, and the number of items already in the bin.\\n\\nDescription: MBU calculates the potential utilization of each bin by dividing the bin capacity by the item size, then adds the number of items already in the bin. The item is assigned to the bin with the highest potential utilization.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the potential utilization for each bin\\n potential_utilizations = bins / item + np.arange(len(bins))\\n # Assign the item to the bin with the highest potential utilization\\n max_potential_utilization_index = np.argmax(potential_utilizations)\\n # Calculate the score for each bin as the inverse of the potential utilization\\n scores = 1 / potential_utilizations\\n # Set the score for the bin with the highest potential utilization to 0\\n scores[max_potential_utilization_index] = 0\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Minimize the maximum score\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Maximum Spread\\\" (MS), assigns an item to the bin with the maximum spread of item sizes, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the spread of item sizes for each bin\\n spreads = np.var(bins)\\n # Assign the item to the bin with the maximum spread of item sizes\\n max_spread_index = np.argmax(spreads)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the spread of item sizes\\n scores = (1 / distances) * spreads\\n # Set the score for the bin with the maximum spread of item sizes to 0\\n scores[max_spread_index] = 0\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as 0\\n scores = np.zeros_like(bins)\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = bins - item\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.sum(bins <= item)\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is called \\\"Maximum Score with Item Size Bonus\\\". It rewards bins based on their sizes to encourage using larger bins when possible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Add a bonus term based on the size of the bin\\n bonus = (bins - min(bins)) / (max(bins) - min(bins))\\n scores += bonus\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the standard deviation of the remaining bins' capacities to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n \\n # Calculate the score based on the item's size, the distance, and the standard deviation\\n scores = np.log(item / distances) + np.log(distances / std_capacity)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Bin Packing with Adaptive Scoring and Item Size Weighting (BPAS-ISW)\\n\\nMain steps:\\n\\n1. Initialize the scores for each bin as a constant value.\\n2. Calculate the absolute difference between the item size and the bin capacity for each bin.\\n3. Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size.\\n4. Adjust the score based on the number of items already assigned to each bin.\\n5. Adjust the score based on the total capacity of the bins.\\n6. Set the score for the bin with the minimum distance to 0.\\n7. Adapt the score based on the number of items already in the bin.\\n8. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the Euclidean distance between the item size and the bin capacity for each bin\\n distances = np.sqrt((bins - item)**2)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Set the score for the bin with the minimum distance to a small negative value\\n scores[np.argmin(distances)] = -0.1\\n # Adapt the score based on the number of items already in the bin, but only for bins with a similar size to the current item\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Minimize Wasted Space\\\" (MWS), assigns an item to the bin with the minimum wasted space, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the minimum wasted space for each bin\\n min_wasted_spaces = np.min(bins - item)\\n # Assign the item to the bin with the minimum wasted space\\n min_wasted_space_index = np.argmin(min_wasted_spaces)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum wasted space to 0\\n scores[min_wasted_space_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the distance between the item size and the bin capacity, and adjust the score based on this distance.\\n\\nNew algorithm: \\\"Adaptive Score with Item Size and Capacity Ratio\\\" (ASC-IR)\\n\\nDescription: ASC-IR calculates the ratio of the item size to the bin capacity for each bin, and adjusts the score based on this ratio, taking into account the number of items already assigned to each bin and the total capacity of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity for each bin\\n ratios = item / bins\\n # Adjust the score based on the ratio, taking into account the number of items already assigned to each bin\\n scores = np.log(ratios) - 0.1 * np.log(np.sum(bins == item))\\n # Set the score for the bin with the maximum ratio to 0\\n scores[np.argmax(ratios)] = 0\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Bin Packing with Adaptive Scoring and Item Size Weighting (BPAS-ISW)\\n\\nMain steps:\\n\\n1. Initialize the scores for each bin as a constant value.\\n2. Calculate the absolute difference between the item size and the bin capacity for each bin.\\n3. Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size.\\n4. Adjust the score based on the number of items already assigned to each bin.\\n5. Adjust the score based on the total capacity of the bins.\\n6. Set the score for the bin with the minimum distance to 0.\\n7. Adapt the score based on the number of items already in the bin.\\n8. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Adjust the score based on the total capacity of the bins\\n scores += 0.1 * np.log(np.sum(bins))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n # Adapt the score based on the number of items already in the bin\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by prioritizing the distance between the item size and the bin capacity, and the number of items already assigned to each bin, while also considering the number of items that can fit in each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items that can fit in each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items that can fit in each bin\\n scores -= np.log(np.sum(bins > item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins.\\nNew algorithm: \\\"Minimize the number of used bins while maximizing the number of items in each bin\\\".\\n\\nDescription: The algorithm assigns an item to the bin with the lowest score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, but with a twist: instead of assigning the item to the bin with the lowest score directly, it first calculates the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity, and then assigns the item to the bin with the lowest score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity\\n scores = (len(bins) - np.count_nonzero(bins)) / distances\\n # Assign the item to the bin with the lowest score\\n min_score_index = np.argmin(scores)\\n # Set the score for the bin with the lowest score to 0\\n scores[min_score_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Binning with Adaptive Fit\\\" (BAF)\\nBAF assigns an item to the bin with the adaptive fit based on the item size, rest capacity of each bin, and the number of items already in the bin, while also considering the standard deviation of the remaining bins' capacities and the item's size relative to the bin's capacity.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * std_capacity\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Adjust the score based on the item's size relative to the bin's capacity\\n scores += 0.1 * item / bins\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n # Adjust the score based on the item's size relative to the bin's capacity\\n scores += 0.1 * np.log(item / bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * np.log(std_capacity)\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms aim to optimize the usage of bins by assigning items to bins with the best fit, considering various factors such as distance, spread, and number of items already in the bins.\\n\\nNew algorithm: \\\"Binning with Dynamic Fit\\\" (BDF)\\nBDF assigns an item to the bin with the dynamic fit based on the item size, rest capacity of each bin, and the number of items already in the bin, while also considering the standard deviation of the remaining bins' capacities and the item's size relative to the bin's capacity.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * std_capacity\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Adjust the score based on the item's size relative to the bin's capacity\\n scores += 0.1 * item / bins\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Binning with Optimal Fit\\\" (BOF)\\nBOF assigns an item to the bin with the optimal fit based on the item size and the rest capacity of each bin, while also considering the number of items already in the bin and the standard deviation of the remaining bins' capacities.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= 0.1 * distances\\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n # Adjust the score based on the standard deviation of the remaining bins' capacities\\n scores += 0.1 * std_capacity\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Set the score for the bin with the optimal fit to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity))\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and also considers the distance between the item's size and the bin's capacity to calculate the score.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Normalize the scores by dividing by the sum of all scores\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Maximum Spread\\\" (MS), assigns an item to the bin with the maximum spread of item sizes, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the spread of item sizes for each bin\\n spreads = np.var(bins)\\n # Assign the item to the bin with the maximum spread of item sizes\\n max_spread_index = np.argmax(spreads)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the spread of item sizes\\n scores = (1 / distances) * spreads\\n # Set the score for the bin with the maximum spread of item sizes to 0\\n scores[max_spread_index] = 0\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as 0\\n scores = np.zeros_like(bins)\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = bins - item\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.sum(bins <= item)\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is called \\\"Maximum Score with Item Size Bonus\\\". It rewards bins based on their sizes to encourage using larger bins when possible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Add a bonus term based on the size of the bin\\n bonus = (bins - min(bins)) / (max(bins) - min(bins))\\n scores += bonus\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the standard deviation of the remaining bins' capacities to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n \\n # Calculate the score based on the item's size, the distance, and the standard deviation\\n scores = np.log(item / distances) + np.log(distances / std_capacity)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Item Size Penalty\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the Euclidean distance between the item size and the bin capacity for each bin\\n distances = np.sqrt((bins - item)**2)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Set the score for the bin with the minimum distance to a small positive value\\n scores[np.argmin(distances)] = 0.1\\n # Adapt the score based on the number of items already in the bin, but only for bins with a similar size to the current item\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Minimize Wasted Space\\\" (MWS), assigns an item to the bin with the minimum wasted space, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the minimum wasted space for each bin\\n min_wasted_spaces = np.min(bins - item)\\n # Assign the item to the bin with the minimum wasted space\\n min_wasted_space_index = np.argmin(min_wasted_spaces)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum wasted space to 0\\n scores[min_wasted_space_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the distance between the item size and the bin capacity, and adjust the score based on this distance.\\n\\nNew algorithm: \\\"Adaptive Score with Item Size and Capacity Ratio\\\" (ASC-IR)\\n\\nDescription: ASC-IR calculates the ratio of the item size to the bin capacity for each bin, and adjusts the score based on this ratio, taking into account the number of items already assigned to each bin and the total capacity of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity for each bin\\n ratios = item / bins\\n # Adjust the score based on the ratio, taking into account the number of items already assigned to each bin\\n scores = np.log(ratios) - 0.1 * np.log(np.sum(bins == item))\\n # Set the score for the bin with the maximum ratio to 0\\n scores[np.argmax(ratios)] = 0\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Bin Packing with Adaptive Scoring and Item Size Weighting (BPAS-ISW)\\n\\nMain steps:\\n\\n1. Initialize the scores for each bin as a constant value.\\n2. Calculate the absolute difference between the item size and the bin capacity for each bin.\\n3. Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size.\\n4. Adjust the score based on the number of items already assigned to each bin.\\n5. Adjust the score based on the total capacity of the bins.\\n6. Set the score for the bin with the minimum distance to 0.\\n7. Adapt the score based on the number of items already in the bin.\\n8. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Adjust the score based on the total capacity of the bins\\n scores += 0.1 * np.log(np.sum(bins))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n # Adapt the score based on the number of items already in the bin\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins while considering the distance between the item size and the bin capacity, and the number of items already assigned to each bin.\\n\\nNew algorithm: \\\"Minimize the number of used bins by prioritizing the distance between the item size and the bin capacity, and the number of items already assigned to each bin, while also considering the number of items that can fit in each bin.\\\"\\n\\nDescription: The algorithm assigns an item to the bin with the minimum score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already assigned to each bin, and the number of items that can fit in each bin.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity\\n scores = 1 / distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores -= np.log(np.sum(bins <= item))\\n # Adjust the score based on the number of items that can fit in each bin\\n scores -= np.log(np.sum(bins > item))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Minimizing the number of used bins.\\nNew algorithm: \\\"Minimize the number of used bins while maximizing the number of items in each bin\\\".\\n\\nDescription: The algorithm assigns an item to the bin with the lowest score, considering the rest capacity of each bin, in order to minimize the number of used bins, while also taking into account the distance between the item size and the bin capacity, and the number of items already in the bin, but with a twist: instead of assigning the item to the bin with the lowest score directly, it first calculates the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity, and then assigns the item to the bin with the lowest score.\\n\\nImplementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the score for each bin as the ratio of the number of items already in the bin to the distance between the item size and the bin capacity\\n scores = (len(bins) - np.count_nonzero(bins)) / distances\\n # Assign the item to the bin with the lowest score\\n min_score_index = np.argmin(scores)\\n # Set the score for the bin with the lowest score to 0\\n scores[min_score_index] = 0\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" My new algorithm is called \\\"Maximum Score with Rest Capacity Penalty\\\". It penalizes bins based on their remaining capacity to discourage using almost full bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Add a penalty term based on the remaining capacity of the bin\\n penalty = (max(bins) - bins) / max(bins)\\n scores -= penalty\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/CodeLlama34B/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances) + np.sqrt(distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Normalize the scores by dividing by the sum of all scores\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size and the distance between the item's size and the bin's capacity to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the scores for each bin based on the item size and the rest capacity of the bins.\\n\\nNew algorithm: \\\"Maximum Score with Item Size Penalty\\\"\\nThis algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various combinations of the item size, the rest capacity of each bin, and the distance between the item size and the maximum capacity of the bins to calculate the score.\\n\\nNew algorithm: The new algorithm uses a combination of the item size, the rest capacity of each bin, and the ratio of the item size to the maximum capacity of the bins to calculate the score.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity)) * (1 - (item / max_capacity))\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n scores[i] = (item / (bins[i] - item + 1)) * (1 - (bins[i] / max_capacity))\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: Assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm: The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and also considers the distance between the item's size and the bin's capacity to calculate the score.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the score based on the item's size and the distance\\n scores = np.log(item / distances)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n # Normalize the scores by dividing by the sum of all scores\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item size and the rest capacity of each bin to calculate the score for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item * bins[bins != bins.max()] / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = np.log(item / (bins[bins != bins.max()] - item + 1))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: \\\"Maximum Score with Restricted Capacity\\\"\\n\\nMain steps: Assign an item to the bin with the maximum score, considering the rest capacity of each bin, while ensuring that the total capacity of all bins does not exceed a certain threshold.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_score = np.max(bins)\\n \\n # Calculate the restricted capacity for each bin\\n restricted_capacity = np.minimum(bins, max_score)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n scores[restricted_capacity > 0] = np.log(item / (restricted_capacity[restricted_capacity > 0] - item + 1))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Dynamic Binning\\\" (DB), dynamically adjusts the scores for each bin based on the current state of the bins and the item being assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as 0\\n scores = np.zeros_like(bins)\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = bins - item\\n # Adjust the score based on the distance between the item size and the bin capacity\\n scores -= distances\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += np.sum(bins <= item)\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is called \\\"Maximum Score with Item Size Bonus\\\". It rewards bins based on their sizes to encourage using larger bins when possible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios with the bin index\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Add a bonus term based on the size of the bin\\n bonus = (bins - min(bins)) / (max(bins) - min(bins))\\n scores += bonus\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of the item's size, the distance between the item's size and the bin's capacity, and the standard deviation of the remaining bins' capacities to calculate the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item's size and the bin's capacity\\n distances = np.abs(bins - item)\\n \\n # Calculate the standard deviation of the remaining bins' capacities\\n std_capacity = np.std(bins)\\n \\n # Calculate the score based on the item's size, the distance, and the standard deviation\\n scores = np.log(item / distances) + np.log(distances / std_capacity)\\n \\n # Set the score to zero if the bin's capacity is equal to the maximum capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / bins[bins != bins.max()]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"Maximum Score with Item Size Penalty\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the Euclidean distance between the item size and the bin capacity for each bin\\n distances = np.sqrt((bins - item)**2)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Set the score for the bin with the minimum distance to a small positive value\\n scores[np.argmin(distances)] = 0.1\\n # Adapt the score based on the number of items already in the bin, but only for bins with a similar size to the current item\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, called \\\"Minimize Wasted Space\\\" (MWS), assigns an item to the bin with the minimum wasted space, considering the distance between the item size and the bin capacity, and the number of items already in the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the distance between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Calculate the minimum wasted space for each bin\\n min_wasted_spaces = np.min(bins - item)\\n # Assign the item to the bin with the minimum wasted space\\n min_wasted_space_index = np.argmin(min_wasted_spaces)\\n # Calculate the score for each bin as the inverse of the distance between the item size and the bin capacity, multiplied by the number of items already in the bin\\n scores = (1 / distances) * (len(bins) - np.count_nonzero(bins))\\n # Set the score for the bin with the minimum wasted space to 0\\n scores[min_wasted_space_index] = 0\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Common backbone idea: The provided algorithms use various methods to calculate the distance between the item size and the bin capacity, and adjust the score based on this distance.\\n\\nNew algorithm: \\\"Adaptive Score with Item Size and Capacity Ratio\\\" (ASC-IR)\\n\\nDescription: ASC-IR calculates the ratio of the item size to the bin capacity for each bin, and adjusts the score based on this ratio, taking into account the number of items already assigned to each bin and the total capacity of the bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity for each bin\\n ratios = item / bins\\n # Adjust the score based on the ratio, taking into account the number of items already assigned to each bin\\n scores = np.log(ratios) - 0.1 * np.log(np.sum(bins == item))\\n # Set the score for the bin with the maximum ratio to 0\\n scores[np.argmax(ratios)] = 0\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Bin Packing with Adaptive Scoring and Item Size Weighting (BPAS-ISW)\\n\\nMain steps:\\n\\n1. Initialize the scores for each bin as a constant value.\\n2. Calculate the absolute difference between the item size and the bin capacity for each bin.\\n3. Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size.\\n4. Adjust the score based on the number of items already assigned to each bin.\\n5. Adjust the score based on the total capacity of the bins.\\n6. Set the score for the bin with the minimum distance to 0.\\n7. Adapt the score based on the number of items already in the bin.\\n8. Return the scores for the bins for assignment.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Initialize the scores for each bin as a constant value\\n scores = 1\\n # Calculate the absolute difference between the item size and the bin capacity for each bin\\n distances = np.abs(bins - item)\\n # Adjust the score based on the distance between the item size and the bin capacity, weighted by the item size\\n scores -= 0.1 * distances * item\\n # Adjust the score based on the number of items already assigned to each bin\\n scores += 0.1 * np.log(np.sum(bins <= item))\\n # Adjust the score based on the total capacity of the bins\\n scores += 0.1 * np.log(np.sum(bins))\\n # Set the score for the bin with the minimum distance to 0\\n scores[np.argmin(distances)] = 0\\n # Adapt the score based on the number of items already in the bin\\n scores += 0.1 * np.log(np.sum(bins == item))\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with greater remaining capacity and takes into consideration the maximum capacity of existing bins when assigning items, aiming to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins[bins >= item]) * (max_capacity / bins[bins >= item])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns scores to each bin based on its remaining capacity and the item's size, where bins with a higher remaining capacity receive higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1/item) * bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the maximum possible item that can be assigned to it, the remaining capacity, and the gap between the bin capacity and item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.maximum(bins[bins >= item] - item, item) - np.maximum(bins[bins >= item] - item - 1, 0)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / bins[bins >= item]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores based on the number of bins needed to accommodate the remaining items after placing the current item in each bin, while maximizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = np.max(np.ceil(bins / item)) # Calculate the maximum number of bins needed to hold the remaining items\\n scores = max_bins * bins - item * np.arange(1, len(bins) + 1) # Calculate scores\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of each bin using a combination of the bin's remaining capacity and the item's size, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment. The algorithm calculates the score for each bin by dividing the available capacity by the square of the difference between 'bins_max' and the available capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask]) ** 2\\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of each bin using a combination of the bin's remaining capacity and the item's size, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item) * np.sqrt(bins[bins != max_capacity] / item)\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of each bin using a combination of the bin's remaining capacity and the item's size, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = np.sqrt(bins[bins != max_capacity] / item)\\n \\n return scores\",\n \"objective\": 0.04769,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm assigns higher scores to bins with smaller rest capacities while considering the difference between the bin's capacity and the item's size and the bin's index, aiming to fill bins more evenly and efficiently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.exp(- bin_capacities[i] / item) * (i + 1)\\n \\n return scores\",\n \"objective\": 0.0488,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score is calculated by a product of the bin capacity and the negative of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -item * bins\\n scores[bins <= item] = np.min(scores) -1\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In contrast to the provided algorithm, this updated algorithm prioritizes bins with greater remaining capacity by utilizing a smaller score decrement for each unit of increased capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item)\\n scores[remaining_capacity > 0] -= remaining_capacity[remaining_capacity > 0] % item\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins > item\\n scores = scores.astype(int)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and the item's size, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = bins[bins != bins.max()] / (item + 1)\\n return scores\",\n \"objective\": 0.06681,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the ratio of their available capacity to the square of the item's size, taking into account the current bin index to improve assignment distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n bin_index = np.arange(len(bins))\\n scores = np.empty_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bin_capacities[i] / item ** 2 * (bin_index[i] + 1)\\n \\n return scores\",\n \"objective\": 0.07023,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign higher scores to bins with larger rest capacities, prioritizing bins with indices closer to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between each bin's rest capacity and the item size\\n differences = bins - item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n differences[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin using a weighted sum of the difference and the bin index, with the weight proportional to the item size\\n scores = differences + np.power(differences, item) * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.07486,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the cube root of the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.power(bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.power(bins - item + 1, 1/3), 1/3)\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.mean(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as a weighted sum of the bin's current utilization, the number of bins used, the difference between the bin's capacity and the item size, and the geometric mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins - item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.max(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on bin capacities, item size, and a penalty for near-full bins to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins + item >= np.max(bins)] -= 1\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Scores are computed as the sum of the bin's current utilization divided by its capacity, the number of times bin has been used, and the harmonic mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + 1/(1/item + 1/bins)\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is computed as the sum of the bin's current utilization, the number of items it contains, the cube roots of the difference between the bin's capacity and the item size, the number of bins that have been used so far, and the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.sum(bins >= item) + np.power(bins - item + 1, 1/3) + np.arange(len(bins)) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.log(bins)\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the sum of the following: a fraction of the item size divided by the difference between the bin's remaining capacity and the item size, plus the square root of the ratio between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.03662,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Maximize the sum of the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size while considering the bin's current utilization and the number of times it has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.sqrt(bins - item) + bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the cube root of the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.power(bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.power(bins - item + 1, 1/3), 1/3)\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the square root of the difference between the bin's capacity and the item size, and the cube root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1) + np.power(bins, 1/3)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as a weighted sum of the bin's current utilization, the number of bins used, the difference between the bin's capacity and the item size, and the harmonic mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins - item) + 2 * bins * item / (bins + item)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.mean(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as a weighted sum of the bin's current utilization, the number of bins used, the difference between the bin's capacity and the item size, and the geometric mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins - item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.max(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate scores based on bin capacities, item size, and a penalty for near-full bins while considering the percentage of remaining capacities in the bins to minimize the number of bins used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins + item >= np.max(bins)] -= 1\\n scores[bins <= item] = 0\\n rem_cap = (bins/np.max(bins))\\n scores = scores - np.log10(rem_cap+1e-10)\\n return scores\",\n \"objective\": 0.02727,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on bin capacities, item size, and a penalty for near-full bins to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins + item >= np.max(bins)] -= 1\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Scores are computed as the sum of the bin's current utilization divided by its capacity, the number of times bin has been used, and the harmonic mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + 1/(1/item + 1/bins)\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the geometric mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/2) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute scores based on a weighted sum of the bin's utilization, the number of items that are already in the bin, the difference between the item's size and the remaining capacity of the bin, and the ratio between the item's size and the bin's total capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins - item + 1 + (item / bins) ** 3\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Maximize the sum of the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size while considering the bin's current utilization and the number of times it has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.sqrt(bins - item) + bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the summation of bins' current utilization, the number of times the bin has been used, the bin's remaining capacity and the cube root of the difference between the bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.power((bins - item + 1), 1/3)\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the square root of the difference between the bin's capacity and the item size, and the cube root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1) + np.power(bins, 1/3)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as a weighted sum of the bin's current utilization, the number of bins used, the difference between the bin's capacity and the item size, and the harmonic mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins - item) + 2 * bins * item / (bins + item)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.mean(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the geometric mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/2) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute scores based on a weighted sum of the bin's utilization, the number of items that are already in the bin, the difference between the item's size and the remaining capacity of the bin, and the ratio between the item's size and the bin's total capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins - item + 1 + (item / bins) ** 3\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Maximize the sum of the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size while considering the bin's current utilization and the number of times it has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.sqrt(bins - item) + bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the summation of bins' current utilization, the number of times the bin has been used, the bin's remaining capacity and the cube root of the difference between the bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.power((bins - item + 1), 1/3)\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the square root of the difference between the bin's capacity and the item size, and the cube root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1) + np.power(bins, 1/3)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as a weighted sum of the bin's current utilization, the number of bins used, the difference between the bin's capacity and the item size, and the harmonic mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins - item) + 2 * bins * item / (bins + item)\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the geometric mean of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/2) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the maximum surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / (bins[surplus > 0] + np.sqrt(item))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute scores based on a weighted sum of the bin's utilization, the number of items that are already in the bin, the difference between the item's size and the remaining capacity of the bin, and the ratio between the item's size and the bin's total capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins - item + 1 + (item / bins) ** 3\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Maximize the sum of the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size while considering the bin's current utilization and the number of times it has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.sqrt(bins - item) + bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the summation of bins' current utilization, the number of times the bin has been used, the bin's remaining capacity and the cube root of the difference between the bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.power((bins - item + 1), 1/3)\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Emphasize bin utilization and item fitting, penalize successive bin usage, and consider capacity relative to item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1) + np.log(bins - item + 1) / np.log(bins) * (bins / (item + 1))\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the modified number of times the bin has been used, the difference between the bin's capacity and the item size, and the cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 2 * np.arange(len(bins)) + bins - item + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the maximum surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / (bins[surplus > 0] + np.sqrt(item))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modify the score function by introducing a parameter 'beta' to control the trade-off between bin utilization and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, beta=1):\\n scores = np.ceil((beta * (bins - np.max(bins)) - item) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the square roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the cube roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.sqrt(bins - item + 1) + np.power(bins, 1/3) * np.power(item, 1/3)\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigning items according to the bin's utilization percentage, usage count, rest capacity, and difference between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log((bins - item + 1)/(bins + 1))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute scores based on a weighted sum of the bin's utilization, the number of items that are already in the bin, the difference between the item's size and the remaining capacity of the bin, and the ratio between the item's size and the bin's total capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins - item + 1 + (item / bins) ** 3\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score includes a reciprocal of bin size penalty and an item size normalized bin utilization; other terms are kept.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1) + np.log(bins - item + 1) / np.log(bins) * (item / bins)\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the modified number of times the bin has been used, the difference between the bin's capacity and the item size, and the cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 2 * np.arange(len(bins)) + bins - item + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the maximum surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / (bins[surplus > 0] + np.sqrt(item))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modify the score function by introducing a parameter 'beta' to control the trade-off between bin utilization and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, beta=1):\\n scores = np.ceil((beta * (bins - np.max(bins)) - item) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the square roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the cube roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.sqrt(bins - item + 1) + np.power(bins, 1/3) * np.power(item, 1/3)\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigning items according to the bin's utilization percentage, usage count, rest capacity, and difference between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log((bins - item + 1)/(bins + 1))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + bins + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute scores based on a weighted sum of the bin's utilization, the number of items that are already in the bin, the difference between the item's size and the remaining capacity of the bin, and the ratio between the item's size and the bin's total capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins - item + 1 + (item / bins) ** 3\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the modified number of times the bin has been used, the difference between the bin's capacity and the item size, and the cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 2 * np.arange(len(bins)) + bins - item + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the reciprocal of the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item) + 1 / np.abs(bins - item) ** 2\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the maximum surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / (bins[surplus > 0] + np.sqrt(item))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modify the score function by introducing a parameter 'beta' to control the trade-off between bin utilization and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, beta=1):\\n scores = np.ceil((beta * (bins - np.max(bins)) - item) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the square roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the cube roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.sqrt(bins - item + 1) + np.power(bins, 1/3) * np.power(item, 1/3)\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the bin's current utilization, the number of times the bin has been used, the arithmetic mean of the bin's capacity and the item size, and the negative cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins + item) / 2 - np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigning items according to the bin's utilization percentage, usage count, rest capacity, and difference between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log((bins - item + 1)/(bins + 1))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + bins + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + bins + 1 / (bins - item) + np.power(bins - item, 1/3)\\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the modified number of times the bin has been used, the difference between the bin's capacity and the item size, and the cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 2 * np.arange(len(bins)) + bins - item + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are developed as the sum of the current utilization of the bins, the number of times the bins have been utilized, the geometric mean of the item's size and bin's capacity, and exponential of difference between the bin's maximum capacity and bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins) + np.exp(bins - bins.max())\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the reciprocal of the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item) + 1 / np.abs(bins - item) ** 2\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, the item utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item) + 1 / np.abs(bins - item) ** 2 + item / bins\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the maximum surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / (bins[surplus > 0] + np.sqrt(item))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modify the score function by introducing a parameter 'beta' to control the trade-off between bin utilization and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, beta=1):\\n scores = np.ceil((beta * (bins - np.max(bins)) - item) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the square roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the cube roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.sqrt(bins - item + 1) + np.power(bins, 1/3) * np.power(item, 1/3)\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the bin's current utilization, the number of times the bin has been used, the arithmetic mean of the bin's capacity and the item size, and the negative cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins + item) / 2 - np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigning items according to the bin's utilization percentage, usage count, rest capacity, and difference between the rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log((bins - item + 1)/(bins + 1))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, the reciprocal of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) + bins + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's total utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, the square roots of the bin's maximum capacity and the item size, and the item's contribution to the bin's fullness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins) * np.sqrt(item) + item * (bins - item + 1) / bins\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The newly developed algorithm calculates the scores based on the bin's current utilization, the number of times the bin has been used, the cubic root of the bin's maximum capacity, the harmonic mean between the item's size and the bin's capacity, the reciprocal of the difference between the bin's remaining capacity and the item's size, and the geometric mean between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins.max(), 1/3) + 2 * item * bins / (item + bins) + 1 / np.abs(bins - item) + np.sqrt(bins - item) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the modified number of times the bin has been used, the difference between the bin's capacity and the item size, and the cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 2 * np.arange(len(bins)) + bins - item + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's total utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, the square roots of the bin's maximum capacity and the item size, and the item's contribution to the bin's fullness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item) + item * (bins - item + 1) / bins\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are developed as the sum of the current utilization of the bins, the number of times the bins have been utilized, the geometric mean of the item's size and bin's capacity, and exponential of difference between the bin's maximum capacity and bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins) + np.exp(bins - bins.max())\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The newly developed algorithm calculates the scores based on the bin's current utilization, the number of times the bin has been used, the cubic root of the bin's maximum capacity, the harmonic mean between the item's size and the bin's capacity, the reciprocal of the difference between the bin's remaining capacity and the item's size, and the geometric mean between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + 2 * item * bins / (item + bins)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, the item utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item) + 1 / np.abs(bins - item) ** 2 + item / bins\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the maximum surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / (bins[surplus > 0] + np.sqrt(item))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the bin's current utilization, the most recent used information, and the variance between the cube roots of the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins + item) / 2 - np.sqrt(np.var(np.power(bins - item + 1, 1/3)))\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modify the score function by introducing a parameter 'beta' to control the trade-off between bin utilization and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, beta=1):\\n scores = np.ceil((beta * (bins - np.max(bins)) - item) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the square roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the cube roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.sqrt(bins - item + 1) + np.power(bins, 1/3) * np.power(item, 1/3)\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and two terms that increase as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1) + np.log(bins) / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with greater remaining capacity and takes into consideration the maximum capacity of existing bins when assigning items, aiming to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins[bins >= item]) * (max_capacity / bins[bins >= item])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm determines the score of each feasible bin based on a weighted combination of the item's size and the bin's remaining capacity, penalized by the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n mask = bins >= item\\n scores[mask] = item / bins[mask] * ((bins[mask] / item) ** 0.3) * ((max_capacity / bins[mask]) ** 1.7)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns scores to each bin based on its remaining capacity and the item's size, where bins with a higher remaining capacity receive higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1/item) * bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the maximum possible item that can be assigned to it, the remaining capacity, and the gap between the bin capacity and item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.maximum(bins[bins >= item] - item, item) - np.maximum(bins[bins >= item] - item - 1, 0)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the weights of the bin's rest capacity and bin's index to adapt to specific scenarios, achieving better performance in minimizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (i + 1) * (1 - bins[i] / item)\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / bins[bins >= item]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores based on the number of bins needed to accommodate the remaining items after placing the current item in each bin, while maximizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = np.max(np.ceil(bins / item)) # Calculate the maximum number of bins needed to hold the remaining items\\n scores = max_bins * bins - item * np.arange(1, len(bins) + 1) # Calculate scores\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the weights of the bin's rest capacity and bin's index to adapt to specific scenarios, achieving better performance in minimizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (1 - bin_capacities[i] / item) * (i + 1) * np.exp(-bins[i] / item)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item/2)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the weights of the bin's rest capacity and bin's index to adapt to specific scenarios, achieving better performance in minimizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.exp(-bin_capacities[i] / item) * (i + 1) * np.exp(-bins[i] / item)\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score calculated as the bin's current capacity divided by the square root of the product of the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins * item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the weights of the bin's rest capacity and bin's index to adapt to specific scenarios, achieving better performance in minimizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (i + 1) * np.exp(-bins[i] / item)\\n \\n return scores\",\n \"objective\": 0.04487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment. The algorithm calculates the score for each bin by dividing the available capacity by the square of the difference between 'bins_max' and the available capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask]) ** 2\\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm utilizes a redesigned score function, which includes the remaining capacity ratio, item size, and square root of the remaining capacity to item size ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = ((bins[bins != max_capacity] - item) / (max_capacity - item) * np.sqrt(bins[bins != max_capacity] / item))**3\\n \\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of each bin using a combination of the bin's remaining capacity and the item's size, taking into account the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item) * np.sqrt(bins[bins != max_capacity] / item)\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores bins based on a combination of their remaining capacity, the item size, and the squared difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.exp(-bin_capacities[i] / item) * (i + 1) * np.exp(-(bins[i] - item) ** 2 / item ** 2)\\n \\n return scores\",\n \"objective\": 0.04709,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm scores based on the bin's total utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, the square roots of the bin's maximum capacity and the item size, and the item's contribution to the bin's fullness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins) * np.sqrt(item) + item * (bins - item + 1) / bins\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The newly developed algorithm calculates the scores based on the bin's current utilization, the number of times the bin has been used, the cubic root of the bin's maximum capacity, the harmonic mean between the item's size and the bin's capacity, the reciprocal of the difference between the bin's remaining capacity and the item's size, and the geometric mean between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins.max(), 1/3) + 2 * item * bins / (item + bins) + 1 / np.abs(bins - item) + np.sqrt(bins - item) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest rest capacity relative to item size, considering only bins with rest capacity below the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.max(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the modified number of times the bin has been used, the difference between the bin's capacity and the item size, and the cube root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 2 * np.arange(len(bins)) + bins - item + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's total utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, the square roots of the bin's maximum capacity and the item size, and the item's contribution to the bin's fullness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3) + np.sqrt(bins) * np.sqrt(item) + item * (bins - item + 1) / bins\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The underlying common concept in the provided algorithms is the combination of bin utilization, usage frequency, and the relationship between bin capacity and item size, which can be extended by adding a logarithmic term to capture the gap between bin capacity and item size.}*\\n\\n* *{The new algorithm scores bins based on the combination of bin utilization, usage frequency, logarithmic difference between bin capacity and item size, and the geometric mean of bin capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.log(bins - item + 1) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the lowest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / bins[surplus > 0]\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores based on the bin's current utilization, the number of times the bin has been used, the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity, and the square roots of the bin's maximum capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/6) + np.power(bins - item + 1, 1/6) + np.sqrt(bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are developed as the sum of the current utilization of the bins, the number of times the bins have been utilized, the geometric mean of the item's size and bin's capacity, and exponential of difference between the bin's maximum capacity and bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins) + np.exp(bins - bins.max())\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The newly developed algorithm calculates the scores based on the bin's current utilization, the number of times the bin has been used, the cubic root of the bin's maximum capacity, the harmonic mean between the item's size and the bin's capacity, the reciprocal of the difference between the bin's remaining capacity and the item's size, and the geometric mean between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + 2 * item * bins / (item + bins)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates a score for each bin based on the bin's current utilization, the number of times the bin has been used, the geometric mean of the bin's capacity and the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, the item utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins * item) + 1 / np.abs(bins - item) + 1 / np.abs(bins - item) ** 2 + item / bins\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm computes the score based on the bin's maximum capacity, the bin's current utilization, the number of times the bin has been used, and the harmonic mean between the item's size and the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins.max() / (bins - item + 1) + bins / (bins - item + 1) + np.arange(len(bins)) + 2 * item * (bins - item) / (item + bins - item)\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: This algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power, where the exponent of the power is a parameter.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**1.5\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin increases with a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)**2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the maximum surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (surplus[surplus > 0] - np.mean(surplus)) / (bins[surplus > 0] + np.sqrt(item))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Take the average of the top three highest scores in the original algorithm and combine it with the mean of the bin capacities.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + (bins + item) / 2 - np.sqrt(np.var(np.power(bins - item + 1, 1/3)))\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin = np.max(bins) # Determine the maximum bin capacity\\n surplus = bins - item # Calculate the surplus capacity in each bin\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - max_bin) / surplus[surplus > 0] # Calculate scores based on relative surplus capacity\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with greater remaining capacity and takes into consideration the maximum capacity of existing bins when assigning items, aiming to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins[bins >= item]) * (max_capacity / bins[bins >= item])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores based on the number of bins needed to accommodate the remaining items after placing the current item in each bin, while maximizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = max(bins / item)\\n scores = (max_bins - 1) * bins - item * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns scores to each bin based on its remaining capacity and the item's size, where bins with a higher remaining capacity receive higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1/item) * bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the linear combination of its relative over-capacity (relative to the item), index, and the inverse of its relative remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n relative_over_capacities = (bins - max_capacity) / max_capacity\\n relative_remaining_capacities = bin_capacities / item\\n scores = -1.0 * relative_over_capacities - np.log(relative_remaining_capacities) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the maximum possible item that can be assigned to it, the remaining capacity, and the square of the gap between the bin capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.maximum(bins[bins >= item] - item, item) - np.power(np.maximum(bins[bins >= item] - item - 1, 0), 2)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the maximum possible item that can be assigned to it, the remaining capacity, and the gap between the bin capacity and item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.maximum(bins[bins >= item] - item, item) - np.maximum(bins[bins >= item] - item - 1, 0)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the weights of the bin's rest capacity and bin's index to adapt to specific scenarios, achieving better performance in minimizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (i + 1) * (1 - bins[i] / item)\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / bins\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins which have over-capacities considering their indices and the inverse of their relative rest capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n relative_over_capacities = (bins - max_capacity) / max_capacity\\n relative_remaining_capacities = bin_capacities / item\\n scores = relative_over_capacities * (1.0 + np.log(relative_remaining_capacities)) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, where the score is calculated as the bin's current capacity divided by the item size, plus the bin's number of remaining items\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores based on the number of bins needed to accommodate the remaining items after placing the current item in each bin, while maximizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = np.max(np.ceil(bins / item)) # Calculate the maximum number of bins needed to hold the remaining items\\n scores = max_bins * bins - item * np.arange(1, len(bins) + 1) # Calculate scores\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the weights of the bin's rest capacity and bin's index to adapt to specific scenarios, achieving better performance in minimizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (1 - bin_capacities[i] / item) * (i + 1) * np.exp(-bins[i] / item)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins[bins >= item] - item/2)\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: Calculate the score for each bin, which is inversely proportional to its rest capacity (relative to the item) and bin's index and modulated by a weight term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (bins[i] / item) * (1 / (i + 1)) * (1 - bin_capacities[i] / item)\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, max_bin=100): # Define a fixed maximum bin capacity\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - max_bin) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus ** 2 / (bins + 1)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins)) + np.sqrt(np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, but it penalizes the bins with smaller rest capacity more heavily, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1)\\n scores[bins < 2 * item] = scores[bins < 2 * item] / 2\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bin utilization and item size, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / surplus - np.arange(len(bins)) * surplus ** 2\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with greater remaining capacity and takes into consideration the maximum capacity of existing bins when assigning items, aiming to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins[bins >= item]) * (max_capacity / bins[bins >= item])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores based on the number of bins needed to accommodate the remaining items after placing the current item in each bin, while maximizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = max(bins / item)\\n scores = (max_bins - 1) * bins - item * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns scores to each bin based on its remaining capacity and the item's size, where bins with a higher remaining capacity receive higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1/item) * bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a weighted sum of the inverse of the remaining capacity and the item size, with a higher weight for the inverse of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1.5 / (bins - item + 1) + 0.5 * item / bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the linear combination of its relative over-capacity (relative to the item), index, and the inverse of its relative remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n bin_capacities = bins - item\\n relative_over_capacities = (bins - max_capacity) / max_capacity\\n relative_remaining_capacities = bin_capacities / item\\n scores = -1.0 * relative_over_capacities - np.log(relative_remaining_capacities) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of its index and the negative logarithm of its relative remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_capacities = bins - item\\n scores = -np.log(bin_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm evaluates bins based on their remaining capacity and the number of bins required to accommodate the remaining items, maximizing the utilization of bins with more space while minimizing the need for additional bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = max(bins / item)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins[bins >= item] / item - np.arange(1, len(bins[bins >= item]) + 1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the maximum possible item that can be assigned to it, the remaining capacity, and the gap between the bin capacity and item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.maximum(bins[bins >= item] - item, item) - np.maximum(bins[bins >= item] - item - 1, 0)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm evaluates each bin based on its remaining capacity after accommodating the item and prioritizes bins with the maximum available space along with the smallest remaining gap.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n rem = bins[bins >= item] - item\\n scores[bins >= item] = np.maximum(rem, item) - rem * np.maximum(rem - 1, 0) / item\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / bins\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index decreases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 + bins - np.arange(len(bins)) + item / (bins - item + 1) + 1\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, max_bin=100): # Define a fixed maximum bin capacity\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - max_bin) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increase. However, it also considers the average of the remaining capacities of all the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / (np.arange(len(bins)) + 1)) + np.mean(bins[bins >= item])\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prefers bins based on their remaining capacity and the space left after assigning the item, maximizing space utilization while considering the size of the item\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / surplus * (surplus + item) - np.arange(len(bins)) * surplus\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases. However, now the fraction term gives more weight to the bins near the current assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / ((np.arange(len(bins)) + 1)**2))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus ** 2 / (bins + 1)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the sum of the following: a fraction of the item size divided by the difference between the bin's remaining capacity and the item size, plus the square root of the ratio between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins - item + 1)) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins)) + np.sqrt(np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns an item to the bin which maximizes a score that is the sum of a bin index term that decreases as the bin index increases, a term that decreases as the remaining capacity of the bin decreases, and a constant that prevents bin index zero from having zero score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.arange(len(bins)) + 1 + item / (bins - item + 1) + 1\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bin utilization and item size, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / surplus - np.arange(len(bins)) * surplus ** 2\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with greater remaining capacity and takes into consideration the maximum capacity of existing bins when assigning items, aiming to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins[bins >= item]) * (max_capacity / bins[bins >= item])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + 0.5\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate scores based on a weighted combination of the inverse of the remaining capacity, the size of the item, and the maximum number of bins needed to accommodate the remaining items after placing the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins - item + 1))**2 + (bins / (bins + item))**2\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores based on the number of bins needed to accommodate the remaining items after placing the current item in each bin, while maximizing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = max(bins / item)\\n scores = (max_bins - 1) * bins - item * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns scores to each bin based on its remaining capacity and the item's size, where bins with a higher remaining capacity receive higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-1/item) * bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index decreases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 + bins - np.arange(len(bins)) + item / (bins - item + 1) + 1\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, max_bin=100): # Define a fixed maximum bin capacity\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - max_bin) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the sum of the following: a fraction of the item size divided by the difference between the bin's remaining capacity and the item size, plus the square root of the ratio between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Iterate through bins to score with better scores if the rest capacities are higher than the capacity. If so, score with item size divided by rest capacity times an item size dependent factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins - item + 1)) * (item / max(bins[bins >= item]))\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increase. However, it also considers the average of the remaining capacities of all the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / (np.arange(len(bins)) + 1)) + np.mean(bins[bins >= item])\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prefers bins based on their remaining capacity and the space left after assigning the item, maximizing space utilization while considering the size of the item\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / surplus * (surplus + item) - np.arange(len(bins)) * surplus\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases. However, now the fraction term gives more weight to the bins near the current assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / ((np.arange(len(bins)) + 1)**2))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus ** 2 / (bins + 1)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the sum of the following: a fraction of the item size divided by the difference between the bin's remaining capacity and the item size, plus the square root of the ratio between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins - item + 1)) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus / (bins + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins)) + np.sqrt(np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns an item to the bin which maximizes a score that is the sum of a bin index term that decreases as the bin index increases, a term that decreases as the remaining capacity of the bin decreases, and a constant that prevents bin index zero from having zero score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = np.arange(len(bins)) + 1 + item / (bins - item + 1) + 1\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bin utilization and item size, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins)) * (bins - item) ** 2\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with greater remaining capacity and takes into consideration the maximum capacity of existing bins when assigning items, aiming to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins[bins >= item]) * (max_capacity / bins[bins >= item])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + 0.5\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the product of a term that increases as the bin index decreases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1 + bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, max_bin=100): # Define a fixed maximum bin capacity\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - max_bin) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the sum of the following: a fraction of the item size divided by the difference between the bin's remaining capacity and the item size, plus the square root of the ratio between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Iterate through bins to score with better scores if the rest capacities are higher than the capacity. If so, score with item size divided by rest capacity times an item size dependent factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins - item + 1)) * (item / max(bins[bins >= item]))\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increase. However, it also considers the average of the remaining capacities of all the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / (np.arange(len(bins)) + 1)) + np.mean(bins[bins >= item])\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prefers bins based on their remaining capacity and the space left after assigning the item, maximizing space utilization while considering the size of the item\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / surplus * (surplus + item) - np.arange(len(bins)) * surplus\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increases. However, now the fraction term gives more weight to the bins near the current assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / ((np.arange(len(bins)) + 1)**2))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus ** 2 / (bins + 1)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bin utilization and item size, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = bins / np.maximum(epsilon, bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus / (bins + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Adds a term to the score that prioritizes bins with a higher capacity. If a bin has a capacity 50% higher than the item, the score is increased by the square root of the difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(np.minimum(bins, item)/item**2) + np.sqrt(1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins)) + np.sqrt(np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increase. However, it also considers the average of the remaining capacities of all the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.mean(bins[bins >= item])\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bin utilization and item size, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins)) * (bins - item) ** 2\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins with greater remaining capacity and takes into consideration the maximum capacity of existing bins when assigning items, aiming to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins[bins >= item]) * (max_capacity / bins[bins >= item])\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.max(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.log(bins)\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the sum of the following: a fraction of the item size divided by the difference between the bin's remaining capacity and the item size, plus the square root of the ratio between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.03662,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Iterate through bins to score with better scores if the rest capacities are higher than the capacity. If so, score with item size divided by rest capacity times an item size dependent factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins - item + 1)) * (item / bins.max())\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin that maximizes a score which includes a capacity term that increases as the remaining capacity of the bin decreases, and also a term that decreases as the bin index increase. However, it also considers the average of the remaining capacities of all the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / (bins - item + 1) + np.sqrt(1 / (np.arange(len(bins)) + 1)) + np.mean(bins[bins >= item])\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prefers bins based on their remaining capacity and the space left after assigning the item, maximizing space utilization while considering the size of the item\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / surplus * (surplus + item) - np.arange(len(bins)) * surplus\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.log(bins)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus ** 2 / (bins + 1)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bin utilization and item size, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = bins / np.maximum(epsilon, bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering both bin utilization and item size with non-uniform weighting of bins, priority is given to bins that can accommodate the item with the least amount of remaining capacity while maximizing the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / (surplus + 1) - np.arange(len(bins)) * surplus / (bins + 1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin by considering the bin's remaining capacity and the size of the item, and then prioritizing bins with smaller remaining capacities and larger capacities relative to the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * (np.maximum(bins - item, 0) / item + 1) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins - item, 1) + np.arange(len(bins)) + np.sqrt(np.maximum(bins - item, 1))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Scores are computed as the sum of the bin's current utilization, the number of times the bin has been used, and the geometric mean between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(item * bins)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Start by calculating a tentative score for each bin by subtracting the bin capacity from the maximum capacity and then dividing the result by the item size. Round the resulting scores down to the nearest integer and, if the rest capacity of a bin is less than or equal to the item size, set its score to 0. Finally, return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score that is calculated as the sum of a term that increases as the bin index increases and a term that increases as the remaining capacity of the bin decreases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = bins - np.arange(len(bins)) + item / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm considers the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + 1 / (bins - item + 1)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.log(bins - item + 1)\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the cube root of the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity, and the cube root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.power(bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.power(bins - item + 1, 1/3), 1/3)\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score as the sum of the bin's current utilization, the number of times the bin has been used, the bin's remaining capacity and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + bins + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.mean(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with the highest surplus capacity relative to item size, considering only bins below the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = np.zeros_like(surplus)\\n scores[surplus > 0] = (bins[surplus > 0] - np.max(bins)) / surplus[surplus > 0]\\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on bin capacities, item size, and a penalty for near-full bins to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ceil((bins - np.max(bins)) / item)\\n scores[bins + item >= np.max(bins)] -= 1\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1) + np.log(bins)\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the sum of the following: a fraction of the item size divided by the difference between the bin's remaining capacity and the item size, plus the square root of the ratio between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / bins) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.sqrt(bins - item + 1)\\n return scores\",\n \"objective\": 0.03662,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the sum of the bin's current utilization, the number of times the bin has been used, and the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Iterate through bins to score with better scores if the rest capacities are higher than the capacity. If so, score with item size divided by rest capacity times an item size dependent factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = (item / (bins - item + 1)) * (item / bins.max())\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the sum of the bin's current utilization, the number of times the bin has been used, and the cube roots of the difference between the bin's capacity and the item size and the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.power(bins - item + 1, 1/3)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prefers bins based on their remaining capacity and the space left after assigning the item, maximizing space utilization while considering the size of the item\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n surplus = bins - item\\n scores = bins / surplus * (surplus + item) - np.arange(len(bins)) * surplus\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, the square root of the difference between the bin's capacity and the item size, and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins)) + np.log(bins)\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the sum of the bin's current utilization, the number of times the bin has been used, and the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins with more remaining capacity by giving them higher scores. If a bin's capacity is less than twice the item's size, assign a score of 0 to it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n scores = np.zeros_like(bins)\\n scores[(capacities > 0) & (capacities < 2 * item)] = 1 / capacities[(capacities > 0) & (capacities < 2 * item)]\\n scores[capacities >= 2 * item] = 1\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the inverse of the ratio of the bin's remaining capacity to the item's size, with a penalty factor for partially used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0.0, 1.0 / ((bins / item) - np.floor(bins / item)))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins.max() - bins - item\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Prioritize empty bins and maximize the utilization rate of bins by calculating the score based on the rest capacity and utilization rate of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1/(1 + np.abs(bins - item))*np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))*np.where(bins == np.max(bins),\\n 3,\\n bins/np.max(bins))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / bins[bins >= item]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm differs in the score function by adding the square of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) ** 2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign items to bins based on a score function, similar to Algorithm 1; Each bin receives the item with the highest score, with a maximum score of one; empty bins are not used; aim to minimize the number of bins used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins\\n scores[scores > 1.0] = 1.0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, while a bin with a score equals zero will not be used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / np.log2(bins[bins != max_capacity])\\n scores[scores == np.inf] = 0.\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm assigns the item to the bin with the maximum score, where the score is calculated as the product of the bin's rest capacity and the inverse of the difference between the size of the item and the rest capacity of the bin, while giving priority to filling bins with a smaller capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * np.where(bins != item, 1 / (bins - item), 0)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins with lower remaining capacities with higher values. If a bin's capacity is equal to the item's size, assign a score of 0 to it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n scores = np.zeros_like(bins)\\n scores[capacities != item] = 1 / capacities[capacities != item]\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the highest score, calculated as the product of bin capacity and the number of items the bin can fit with current item\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n fit_count = (bin_capacity - item) // item\\n scores[i] = bin_capacity * fit_count\\n \\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins based on the following score formula: score = (1 - (bin capacity / maximum capacity)) * ( remaining capacity / item size ) * (remaining capacity / remaining capacity after placing the item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (1 - (bins / max_capacity)) * (bins - item) / item * (bins - item) / np.maximum(bins - 2 * item, 1)\\n\\n return scores\",\n \"objective\": 0.11591,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin by dividing the remaining capacity of the bin by the square root of the difference between the maximum bin capacity and the current item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = bins[bins != max_capacity] / np.sqrt(max_capacity - item)\\n return scores\",\n \"objective\": 0.11732,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates scores by taking the natural logarithm of the ratios, multiplying them by an increasing factor, and adding a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = np.log(bins.astype(float) / item)\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor and adding a constant\\n scores = ratios * np.arange(1, len(bins)+1) + 1\\n \\n return scores\",\n \"objective\": 0.12899,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a higher score to bins that are closer to being filled up to their maximum capacity, giving priority to bins that are close to becoming full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -np.abs(bins-item) - np.square(bins-np.max(bins)) / np.max(bins)\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, while penalizing bins with a smaller capacity than the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / (bins[bins != max_capacity] - item + 1)\\n scores[bins == max_capacity] = np.log10(max_capacity)\\n return scores\",\n \"objective\": 0.13251,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with higher remaining capacity by incorporating a logarithmic function that assigns higher scores to bins with greater capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities / item ** 2\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm considers the number of items in the bin, the current bin capacity, and the total number of items in all bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items_per_bin = bins / item\\n bin_capacities = bins - item\\n total_num_items = np.sum(num_items_per_bin)\\n total_bin_capacities = np.sum(bin_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_per_bin - np.floor(num_items_per_bin)) / (1.0 - (num_items_per_bin - np.floor(num_items_per_bin)))) * (1.0 + bin_capacities / (total_bin_capacities - bin_capacities)) * (1.0 + total_num_items / (total_bin_capacities - total_num_items))\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with lower scores to prioritize their utilization, and factor in the relative remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 + np.where(remaining_capacities <= (max_capacity / 10), np.log(remaining_capacities / item), 0.0)\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity and the inverse of the square root of the number of items in the bin, with weights adjusted by the square of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (np.log(num_items_in_bin + 1) + 1) * remaining_capacities * (bins ** 2) / ((bins / item) - np.floor(bins / item)) ** 2 * 1.0 / (max_capacity ** 2)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm evaluates the bin score based on a weighted combination of the bin capacity and the ratio of the item size to the bin capacity, while considering the current remaining capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * (1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))) + (max_capacity - bins) / (max_capacity - item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - (bins // item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity by scoring them exponentially based on their capacity ratio and penalizing bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp(remaining_capacities / max_capacity)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Computes a score for each bin based on its capacity modulation, weighted by its remaining capacity and penalized for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm assigns items to bins by evaluating the bin score based on a combination of the bin's remaining capacity, the bin's maximum capacity, and the item size, while also considering the number of items in each bin and the total number of items in all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n total_num_items = np.sum(num_items_in_bin)\\n total_bin_capacities = np.sum(bins)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_in_bin - np.floor(num_items_in_bin)) / (1.0 - (num_items_in_bin - np.floor(num_items_in_bin)))) * (1.0 + (remaining_capacities / np.max(remaining_capacities)) * (1.0 + (bins / max_capacity))) * (1.0 + (total_num_items / total_bin_capacities))\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Minimize the number of bins by scoring bins based on their capacity and utilization ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n if bins[bins.shape[0]-1] >= max_capacity:\\n bins[bins.shape[0]-1] = max_capacity - item\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the ratio of the maximum achievable capacity to the actual capacity for each bin if the current item would be assigned to it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (np.floor((bins + item) / max_capacity) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the cubic root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) ** 2 * (bins ** (1/3)) / (max_capacity ** (1/3))\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with higher remaining capacity by incorporating a logarithmic function that assigns higher scores to bins with greater capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities / item ** 2\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm considers the number of items in the bin, the current bin capacity, and the total number of items in all bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items_per_bin = bins / item\\n bin_capacities = bins - item\\n total_num_items = np.sum(num_items_per_bin)\\n total_bin_capacities = np.sum(bin_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_per_bin - np.floor(num_items_per_bin)) / (1.0 - (num_items_per_bin - np.floor(num_items_per_bin)))) * (1.0 + bin_capacities / (total_bin_capacities - bin_capacities)) * (1.0 + total_num_items / (total_bin_capacities - total_num_items))\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity and greater occupancy while penalizing bins with low remaining capacity and high occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n occupancy_rate = 1.0 - remaining_capacities / bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * (1.0 + np.exp(-occupancy_rate / (1.0 - occupancy_rate))) / (1.0 + np.exp(-(remaining_capacities / item) / (remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with lower scores to prioritize their utilization, and factor in the relative remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 + np.where(remaining_capacities <= (max_capacity / 10), np.log(remaining_capacities / item), 0.0)\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity and the inverse of the square root of the number of items in the bin, with weights adjusted by the square of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (np.log(num_items_in_bin + 1) + 1) * remaining_capacities * (bins ** 2) / ((bins / item) - np.floor(bins / item)) ** 2 * 1.0 / (max_capacity ** 2)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(bins / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score by combining the basic component of the previous algorithms, a capacity modulation factor, and a score decay factor penalized for bins with a low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5 * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / (bins / item - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-remaining_capacities))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - (bins // item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity by scoring them exponentially based on their capacity ratio and penalizing bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp(remaining_capacities / max_capacity)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Computes a score for each bin based on its capacity modulation, weighted by its remaining capacity and penalized for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm assigns items to bins by evaluating the bin score based on a combination of the bin's remaining capacity, the bin's maximum capacity, and the item size, while also considering the number of items in each bin and the total number of items in all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n total_num_items = np.sum(num_items_in_bin)\\n total_bin_capacities = np.sum(bins)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_in_bin - np.floor(num_items_in_bin)) / (1.0 - (num_items_in_bin - np.floor(num_items_in_bin)))) * (1.0 + (remaining_capacities / np.max(remaining_capacities)) * (1.0 + (bins / max_capacity))) * (1.0 + (total_num_items / total_bin_capacities))\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with higher remaining capacity by incorporating a logarithmic function that assigns higher scores to bins with greater capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities / item ** 2\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the exponent of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a combination of logarithmic and exponential functions, considering the item size, bin capacity, and an adjustment factor to encourage utilization of less-filled bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item)\\n score_2 = np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n score_3 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 + score_3 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm considers the number of items in the bin, the current bin capacity, and the total number of items in all bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items_per_bin = bins / item\\n bin_capacities = bins - item\\n total_num_items = np.sum(num_items_per_bin)\\n total_bin_capacities = np.sum(bin_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_per_bin - np.floor(num_items_per_bin)) / (1.0 - (num_items_per_bin - np.floor(num_items_per_bin)))) * (1.0 + bin_capacities / (total_bin_capacities - bin_capacities)) * (1.0 + total_num_items / (total_bin_capacities - total_num_items))\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))))\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity and greater occupancy while penalizing bins with low remaining capacity and high occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n occupancy_rate = 1.0 - remaining_capacities / bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * (1.0 + np.exp(-occupancy_rate / (1.0 - occupancy_rate))) / (1.0 + np.exp(-(remaining_capacities / item) / (remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity and the inverse of the square root of the number of items in the bin, with weights adjusted by the square of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (np.log(num_items_in_bin + 1) + 1) * remaining_capacities * (bins ** 2) / ((bins / item) - np.floor(bins / item)) ** 2 * 1.0 / (max_capacity ** 2)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(bins / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score by combining the basic component of the previous algorithms, a capacity modulation factor, and a score decay factor penalized for bins with a low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5 * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / (bins / item - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-remaining_capacities))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - (bins // item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity by scoring them exponentially based on their capacity ratio and penalizing bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp(remaining_capacities / max_capacity)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with higher remaining capacity by incorporating a logarithmic function that assigns higher scores to bins with greater capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities / item ** 2\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the exponent of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a combination of logarithmic and exponential functions, considering the item size, bin capacity, and an adjustment factor to encourage utilization of less-filled bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item)\\n score_2 = np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n score_3 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 + score_3 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm considers the number of items in the bin, the current bin capacity, and the total number of items in all bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items_per_bin = bins / item\\n bin_capacities = bins - item\\n total_num_items = np.sum(num_items_per_bin)\\n total_bin_capacities = np.sum(bin_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_per_bin - np.floor(num_items_per_bin)) / (1.0 - (num_items_per_bin - np.floor(num_items_per_bin)))) * (1.0 + bin_capacities / (total_bin_capacities - bin_capacities)) * (1.0 + total_num_items / (total_bin_capacities - total_num_items))\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))))\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity and greater occupancy while penalizing bins with low remaining capacity and high occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n occupancy_rate = 1.0 - remaining_capacities / bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * (1.0 + np.exp(-occupancy_rate / (1.0 - occupancy_rate))) / (1.0 + np.exp(-(remaining_capacities / item) / (remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A common theme is to score bins based on their remaining capacity and penalize bins with lower capacity. My new algorithm scores bins based on their relative remaining capacity and the potential number of items they can hold after adding the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp((remaining_capacities / max_capacity) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(bins / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score by combining the basic component of the previous algorithms, a capacity modulation factor, and a score decay factor penalized for bins with a low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5 * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize bins with lower remaining capacities to balance loads using a sigmoid function, encouraging assigning items to bins with higher remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 /((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / (bins / item - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-remaining_capacities))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - (bins // item)) * bins ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity by scoring them exponentially based on their capacity ratio and penalizing bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp(remaining_capacities / max_capacity)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2) * np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Further penalizing bins with low remaining capacity by multiplying the exponent of the logarithmic component by $\\\\sqrt{(max\\\\_capacity -remaining\\\\_capacities)}$\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.sqrt(max_capacity - remaining_capacities)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the exponent of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a combination of logarithmic and exponential functions, considering the item size, bin capacity, and an adjustment factor to encourage utilization of less-filled bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item)\\n score_2 = np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n score_3 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 + score_3 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm considers the number of items in the bin, the current bin capacity, and the total number of items in all bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items_per_bin = bins / item\\n bin_capacities = bins - item\\n total_num_items = np.sum(num_items_per_bin)\\n total_bin_capacities = np.sum(bin_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_per_bin - np.floor(num_items_per_bin)) / (1.0 - (num_items_per_bin - np.floor(num_items_per_bin)))) * (1.0 + bin_capacities / (total_bin_capacities - bin_capacities)) * (1.0 + total_num_items / (total_bin_capacities - total_num_items))\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))))\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity and greater occupancy while penalizing bins with low remaining capacity and high occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n occupancy_rate = 1.0 - remaining_capacities / bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * (1.0 + np.exp(-occupancy_rate / (1.0 - occupancy_rate))) / (1.0 + np.exp(-(remaining_capacities / item) / (remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item)) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A common theme is to score bins based on their remaining capacity and penalize bins with lower capacity. My new algorithm scores bins based on their relative remaining capacity and the potential number of items they can hold after adding the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp((remaining_capacities / max_capacity) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(bins / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score by combining the basic component of the previous algorithms, a capacity modulation factor, and a score decay factor penalized for bins with a low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5 * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize bins with lower remaining capacities to balance loads using a sigmoid function, encouraging assigning items to bins with higher remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 /((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / (bins / item - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-remaining_capacities))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2) * np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins[-1]\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Further penalizing bins with low remaining capacity by multiplying the exponent of the logarithmic component by $\\\\sqrt{(max\\\\_capacity -remaining\\\\_capacities)}$\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.sqrt(max_capacity - remaining_capacities)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the exponent of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm multiplies the logarithmic component by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a combination of logarithmic and exponential functions, considering the item size, bin capacity, and an adjustment factor to encourage utilization of less-filled bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item)\\n score_2 = np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n score_3 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 + score_3 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the power of the rest capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins ** 2 / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm considers the number of items in the bin, the current bin capacity, and the total number of items in all bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items_per_bin = bins / item\\n bin_capacities = bins - item\\n total_num_items = np.sum(num_items_per_bin)\\n total_bin_capacities = np.sum(bin_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_per_bin - np.floor(num_items_per_bin)) / (1.0 - (num_items_per_bin - np.floor(num_items_per_bin)))) * (1.0 + bin_capacities / (total_bin_capacities - bin_capacities)) * (1.0 + total_num_items / (total_bin_capacities - total_num_items))\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))))\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity and greater occupancy while penalizing bins with low remaining capacity and high occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n occupancy_rate = 1.0 - remaining_capacities / bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * (1.0 + np.exp(-occupancy_rate / (1.0 - occupancy_rate))) / (1.0 + np.exp(-(remaining_capacities / item) / (remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item)) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A common theme is to score bins based on their remaining capacity and penalize bins with lower capacity. My new algorithm scores bins based on their relative remaining capacity and the potential number of items they can hold after adding the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp((remaining_capacities / max_capacity) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a sigmoid function to penalize bins with higher loads, which encourages assigning items to bins with lower loads to balance the loads.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(bins / max_capacity - 0.5)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score by combining the basic component of the previous algorithms, a capacity modulation factor, and a score decay factor penalized for bins with a low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5 * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2)\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2) * np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins[-1]\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the power of the rest capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiply the square root of the maximum capacity for each bin by the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.sqrt(max_capacity) * (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the exponent of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to bins with higher priority to lower-used bins but give a moderate weight to the logarithmic part.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins + 2) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm multiplies the logarithmic component by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a combination of logarithmic and exponential functions, considering the item size, bin capacity, and an adjustment factor to encourage utilization of less-filled bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item)\\n score_2 = np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n score_3 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 + score_3 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the logarithmic component by the maximum possible number of items that can be packed into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_num_items = np.ceil(bins / item).astype(int)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) * max_num_items\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the power of the rest capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins ** 2 / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm considers the number of items in the bin, the current bin capacity, and the total number of items in all bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items_per_bin = bins / item\\n bin_capacities = bins - item\\n total_num_items = np.sum(num_items_per_bin)\\n total_bin_capacities = np.sum(bin_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + (num_items_per_bin - np.floor(num_items_per_bin)) / (1.0 - (num_items_per_bin - np.floor(num_items_per_bin)))) * (1.0 + bin_capacities / (total_bin_capacities - bin_capacities)) * (1.0 + total_num_items / (total_bin_capacities - total_num_items))\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))))\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity and greater occupancy while penalizing bins with low remaining capacity and high occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n occupancy_rate = 1.0 - remaining_capacities / bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * (1.0 + np.exp(-occupancy_rate / (1.0 - occupancy_rate))) / (1.0 + np.exp(-(remaining_capacities / item) / (remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item)) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it and the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm squares the score function and adds the maximum capacity of the bin to the input item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2 + bins.max() + item\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2) * np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adds the square root of the bin's maximum capacity to the item size and multiplies the score function by the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2 * bins.max() + np.sqrt(bins.max()) + item\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins[-1]\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is determined by the square root of how many items are already in the bin, the remaining capacity of the bin, and the size of the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * np.log(bins) ** (np.arange(len(bins)) ** 1.3)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm aims to maximize the normalized logarithmic component multiplied by the third power of distance between the bin capacity and the average of bin capacities\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) * (np.square(bins - avg_bin))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the power of the rest capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm combines the essence of logarithmic part and exponential function, giving priority to less-occupied bins with higher remaining capacities for accommodating the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item) * np.log(bins + 2) ** np.arange(len(bins))\\n score_2 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used and add it to the result of dividing the bin capacity by the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the exponent of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to bins with higher priority to lower-used bins but give a moderate weight to the logarithmic part.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins + 2) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm multiplies the logarithmic component by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Rate based on the log of the rest capacity of each bin multiplied by the inverse exponent of the number of times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) ** (np.arange(len(bins)) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a combination of logarithmic and exponential functions, considering the item size, bin capacity, and an adjustment factor to encourage utilization of less-filled bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item)\\n score_2 = np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n score_3 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 + score_3 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the logarithmic component by the maximum possible number of items that can be packed into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_num_items = np.ceil(bins / item).astype(int)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) * max_num_items\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the power of the rest capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins ** 2 / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute a score based on the square of the exponential function of maximum achievable capacity for each bin if the current item would be assigned to it divided by the number of already contained items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = - (np.square(np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))) / (np.floor(bins / item) + 1))\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm squares the score function and adds the maximum capacity of the bin to the input item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2 + bins.max() + item\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2) * np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Raise the input item size to the power of maximum capacity, and then square the score function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins + item) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2) ** 2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the score function by the square root of the bin's maximum capacity and adds the square of both the item size and the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2 * bins.max() + np.sqrt(bins.max())) ** 2 + (item ** 2 + bins.max())\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins[-1]\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score is determined by the number of items the bin could accommodate besides the current item, the number of items the bin already contains, and the difference between the bin's capacity and the current item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * np.log(bins - item) * bins / (bins - item + np.arange(len(bins)) ** 2)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is determined by the square root of how many items are already in the bin, the remaining capacity of the bin, and the size of the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * np.log(bins) ** (np.arange(len(bins)) ** 1.3)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm aims to maximize the normalized logarithmic component multiplied by the third power of distance between the bin capacity and the average of bin capacities\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) * (np.square(bins - avg_bin))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first finds the smallest bin that can accommodate the item if such a bin exists, then gives higher priority to used bins. The items are packed into the bins in a way that minimizes the number of used bins and makes the item distribution over bins as uniform as possible.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n inds = np.argwhere(bins >= item).flatten()\\n if len(inds) == 0:\\n return np.zeros(len(bins))\\n smallest_feasible_bin_idx = inds[0] \\n smallest_feasible_bin = bins[inds[0]]\\n scores = bins / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n scores[inds] *= np.arange(len(inds))\\n scores[smallest_feasible_bin_idx] /= np.log(smallest_feasible_bin + 1) ** 2\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the power of the rest capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted Algorithm: Assigns bins with less remaining capacity and higher scores to the current item, considering their occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = (bins / bins + 1) * np.log(bins + 2) ** np.arange(len(bins))\\n score_2 = 1.0 / ((remaining_capacities / item) * (bins / item))\\n scores = score_1 * score_2 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic component by the number of times a bin has been used and add it to the result of dividing the bin capacity by the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the exponent of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to bins with higher priority to lower-used bins but give a moderate weight to the logarithmic part.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins + 2) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm multiplies the logarithmic component by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Rate based on the log of the rest capacity of each bin multiplied by the inverse exponent of the number of times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) ** (np.arange(len(bins)) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a combination of logarithmic and exponential functions, considering the item size, bin capacity, and an adjustment factor to encourage utilization of less-filled bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = bins / (bins - item)\\n score_2 = np.log(bins) ** (np.arange(len(bins)) ** 1) * np.arange(len(bins))\\n score_3 = np.exp(-(np.floor(bins / item) + 1) * (1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2))\\n scores = score_1 * score_2 + score_3 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the logarithmic component by the maximum possible number of items that can be packed into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_num_items = np.ceil(bins / item).astype(int)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) * max_num_items\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm subtracts a normalized logarithmic component and the exponential function, then multiplied by a cubic form of the available rest capacity\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 3 * (bins ** 3 / avg_bin ** 2) - np.exp(bins / avg_bin)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm subtracts the multiplication of the item size and the bin's maximum capacity from the square of the score function multiplied by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(bins/(bins - item) + np.log(bins)**(np.arange(len(bins))**1) * bins.max())\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2) * np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Raise the input item size to the power of maximum capacity, and then square the score function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins + item) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2) ** 2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm comprises the subtraction of the square of the item size multiplied by the sum of the bin's rest capacity and the average of all bins from the quotient of the normalized logarithmic component and the cube of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n numerator = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1))\\n denominator = bins.max() ** 3 * (bins + avg_bin)\\n scores = ((numerator / denominator) - item ** 2) ** 2\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the score function by the square root of the bin's rest capacity and adds the product of item size and the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) * ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) ** 2 + np.sqrt(bins.max())) + item * bins.max()\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm subtracts the multiplication of the item size and the bin's maximum capacity from the square of the score function multiplied by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2 * bins.max() - item * bins.max()) ** 2\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins[-1]\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the score function by the square root of the bin's maximum capacity and adds the square of both the item size and the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) ** 2 + np.sqrt(bins.max())) ** 2 + (item ** 2 + bins.max())\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score is determined by the number of items the bin could accommodate besides the current item, the number of items the bin already contains, and the difference between the bin's capacity and the current item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * np.log(bins - item) * bins / (bins - item + np.arange(len(bins)) ** 2)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is determined by the square root of how many items are already in the bin, the remaining capacity of the bin, and the size of the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * np.log(bins) ** (np.arange(len(bins)) ** 1.3)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n remaining_capacities = (bins - item) / avg_capacity\\n scores = np.log(1. / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm aims to maximize the normalized logarithmic component multiplied by the third power of distance between the bin capacity and the average of bin capacities\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) * (np.square(bins - avg_bin))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the cube of the score function multiplied by the bin's maximum capacity by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 3 / bins) ** 2\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm subtracts the square of the item size multiplied by the sum of the bin's rest capacity and the average of all bins from the product of the normalized logarithmic component and the cube of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n scores = ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 3 * (bins + avg_bin) - item ** 2) ** 2\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm boosts the weight of the logarithmic part with the power of the rest capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.log(bins + 1) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted Algorithm: Assigns bins with less remaining capacity and higher scores to the current item, considering their occupancy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n score_1 = (bins / bins + 1) * np.log(bins + 2) ** np.arange(len(bins))\\n score_2 = 1.0 / ((remaining_capacities / item) * (bins / item))\\n scores = score_1 * score_2 * remaining_capacities / max_capacity\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm multiplies the logarithmic part of the score function with the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item / (bins - item) * np.log(bins) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm multiplies the logarithmic component by the square of the maximum capacity of the bin\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * (bins.max()) ** 2\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_remaining_capacity = np.mean(bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the inverse of the number of partially used bins, and 3. the inverse of the square of the difference between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used_bins + 1)) + 1.0 / ((bins - item) ** 2 + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted combination of the inverse of the ratio of the bin's remaining capacity to the item's size and the inverse of the number of partially used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used_bins + 1))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with more remaining capacity by giving them higher scores. If a bin's capacity is less than twice the item's size, assign a score of 0 to it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n scores = np.zeros_like(bins)\\n scores[(capacities > 0) & (capacities < 2 * item)] = 1 / capacities[(capacities > 0) & (capacities < 2 * item)]\\n scores[capacities >= 2 * item] = 1\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted combination of the inverse of the remaining capacity and the inverse of the difference between the bin's capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / remaining_capacities + 1.0 / ((bins / item) - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the inverse of the ratio of the bin's remaining capacity to the item's size, with a penalty factor for partially used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0.0, 1.0 / ((bins / item) - np.floor(bins / item)))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the lowest score calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, minus the number of times the bin has been used. The bin with the lowest score is guaranteed to have the most remaining capacity after the item is assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item)**2 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score of each bin by taking the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, and adding the bin's ID.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm differs in the score function by adding the logarithm of the bin capacity to power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 2)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combine the idea of prioritizing empty bins and maximizing bin utilization from Algorithm 2 with the idea of using the inverse of the difference between item size and bin capacity from Algorithm 3, while adding a penalty for bins that have been used more than once.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (1 / (np.abs(bins - item) + 1)) * np.where(bins == max_capacity, 0.0, np.where(bins == max_capacity - item, -1, 1)) * np.where(bins > max_capacity, 1, bins / max_capacity)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm differs in the score function by adding a combination of a power function and the capacity of bins to the score\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins ** (np.arange(len(bins)) ** 2)\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = item / bins[bins >= item]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm differs in the score function by adding the square of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) ** 2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates the ratio of the bin's residual capacity to the maximum capacity and multiplies it by the antilog of the square of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / bins.max()) * (np.e ** -(np.arange(len(bins)) ** 2))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm assigns the item to the bin with the maximum score, where the score is calculated as the product of the bin's rest capacity and the inverse of the difference between the size of the item and the rest capacity of the bin, while giving priority to filling bins with a smaller capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.full_like(bins, 1 / len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm subtracts a normalized logarithmic component and the exponential function, then multiplied by a cubic form of the available rest capacity\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 3 * (bins ** 3 / avg_bin ** 2) - np.exp(bins / avg_bin)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the score function by the sum of the rest capacity and the item size, and then subtracts the item size by the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins + 1) ** (np.arange(len(bins)) ** 1) * bins.max()) * (bins + item) - item * bins) ** 2\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm subtracts the multiplication of the item size and the bin's maximum capacity from the square of the score function multiplied by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(bins/(bins - item) + np.log(bins)**(np.arange(len(bins))**1) * bins.max())\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score is determined by how much remaining capacity a bin has, how many items are already in the bin, and the size of the current item. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1.2) * np.log(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Raise the input item size to the power of maximum capacity, and then square the score function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins + item) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2) ** 2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the score function by the square of the bin's rest capacity and adds the square of the item size for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(bins) * ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)))) ** 2 + np.square(bins.max())) + np.square(item) * bins.max()\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the score function by the square root of the bin's rest capacity and adds the product of item size and the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) * ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) ** 2 + np.sqrt(bins.max())) + item * bins.max()\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is determined by the square root of how many items are already in the bin, the remaining capacity of the bin, the size of the current item, and the ratio of the remaining capacity of the bin to the size of the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * (bins - item) / item * np.log(bins) ** (np.arange(len(bins)) ** 1.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Consider a new score function, which takes the square root of the given score and multiplies it with the current bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(((bins / (bins - item) + np.log(bins + item) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2)) * bins\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm subtracts the multiplication of the item size and the bin's maximum capacity from the square of the score function multiplied by the maximum capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1) * bins.max()) ** 2 * bins.max() - item * bins.max()) ** 2\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combined the remainder of the bins into the square and multiplied the average of all bins by the denominator to provide a better trade-off.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n numerator = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1))\\n denominator = bins.max() ** 3 * (bins + avg_bin) ** 2\\n scores = ((numerator / denominator) - item ** 2) ** 2\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins[-1]\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Raise the input item size to the power of the bins' rest capacity and the square root of the maximum capacity, and then square the score function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins + item) ** (np.arange(len(bins)) ** 1) * np.sqrt(bins.max())) ** 2) ** 2\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the score function by the square root of the bin's maximum capacity and adds the square of both the item size and the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) ** 2 + np.sqrt(bins.max())) ** 2 + (item ** 2 + bins.max())\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The score is determined by the number of items the bin could accommodate besides the current item, the number of items the bin already contains, and the difference between the bin's capacity and the current item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * np.log(bins - item) * bins / (bins - item + np.arange(len(bins)) ** 2)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is determined by the square root of how many items are already in the bin, the remaining capacity of the bin, and the size of the current item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * np.log(bins) ** (np.arange(len(bins)) ** 1.3)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the remaining capacity with its logarithm to prioritize bins with higher capacity and discourage assigning to bins that are nearly full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n remaining_capacities = (bins - item) / avg_capacity\\n scores = np.log(1. / remaining_capacities) * remaining_capacities\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalizes bins with small rest capacities by dividing the score function multiplied by the bin's maximum capacity by the multiplication of the rest capacity and bin's maximum capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = ((bins / (bins - item) + np.log(bins)**(np.arange(len(bins))**1) * bins.max()) ** 3 / bins / bins.max()) ** 2\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm aims to maximize the normalized logarithmic component multiplied by the third power of distance between the bin capacity and the average of bin capacities\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin = np.mean(bins)\\n scores = (bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)) * (np.square(bins - avg_bin))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_remaining_capacity = np.mean(bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(1))\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n random_numbers = np.random.rand(len(bins))\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(num_partially_used_bins)) * random_numbers\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the remaining capacity of the bin, and 3. the inverse of the number of items that can fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(remaining_capacities) + 1.0 / (remaining_capacities / item + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the bin's remaining capacity and the inverse of the number of partially used bins, weighted by the difference between the bin's capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(remaining_capacities / item))) / (num_partially_used_bins + 1)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of the ratio of the bin's current capacity to the item's size and the inverse of the number of partially used bins, considering the variance in the available bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n bin_capacity_variance = np.var(bins)\\n scores = (bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * (num_partially_used_bins + 1) / (bin_capacity_variance + 1)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm uses a weighted score that combines the bin's remaining capacity, the weighted inverse of the number of items in the bin, and the item's size, with the weights adjusted based on the score from the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n base_scores = (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(remaining_capacities / item))) / (num_partially_used_bins + 1)\\n num_items_in_bin = np.floor(bins / item)\\n weights = 1.0 + np.log(num_items_in_bin + 1)\\n scores = base_scores * weights\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the inverse of the number of partially used bins, and 3. the inverse of the square of the difference between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used = remaining_capacities > 0\\n num_partially_used = partially_used.sum()\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used + 1)) + 1.0 / ((bins - item) ** 2 + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the inverse of the number of partially used bins, and 3. the inverse of the square of the difference between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used_bins + 1)) + 1.0 / ((bins - item) ** 2 + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted combination of the inverse of the ratio of the bin's remaining capacity to the item's size and the inverse of the number of partially used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used_bins + 1))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to the bin with the highest score calculated by a function of the ratio of the bin's remaining capacity to the item's size, with a bonus for bins where the remaining capacity after assignment is less than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0.0, 1.0 / ((bins / item) - np.floor(bins / item))) + (bins > max_capacity / 2)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with more remaining capacity by giving them higher scores. If a bin's capacity is less than twice the item's size, assign a score of 0 to it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n scores = np.zeros_like(bins)\\n scores[(capacities > 0) & (capacities < 2 * item)] = 1 / capacities[(capacities > 0) & (capacities < 2 * item)]\\n scores[capacities >= 2 * item] = 1\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted combination of the inverse of the ratio of the bin's remaining capacity to the item's size and the inverse of the number of partially used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, threshold=1.0):\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (1 + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03642,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted combination of the inverse of the remaining capacity and the inverse of the difference between the bin's capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / remaining_capacities + 1.0 / ((bins / item) - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins based on a non-linear combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the number of partially used bins, and 3. the exponential of the difference between the bin's remaining capacity and the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.exp(-(bins - item))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the inverse of the ratio of the bin's remaining capacity to the item's size, with a penalty factor for partially used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0.0, 1.0 / ((bins / item) - np.floor(bins / item)))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins based on a non-linear combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the number of partially used bins, and 3. the exponential of the difference between the bin's remaining capacity and the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(np.where(bins == max_capacity, 1, num_partially_used_bins + 1)) + np.exp(-(bins - item))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on the inverse of the ratio of the bin's remaining capacity and the item's size, modified by the square root of the bin's total capacity and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n total_capacities = bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(total_capacities) + np.sqrt(remaining_capacities)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n weights = (np.sqrt(bins / max_capacity)) * (1.0 + np.exp(-(remaining_capacities / item))) / (np.sqrt(num_items_in_bin + 1))\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n random_numbers = np.random.rand(len(bins))\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(num_partially_used_bins)) * random_numbers\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the remaining capacity of the bin, and 3. the inverse of the number of items that can fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(remaining_capacities) + 1.0 / (remaining_capacities / item + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the bin's remaining capacity and the inverse of the number of partially used bins, weighted by the difference between the bin's capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = 1\\n scores = (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(remaining_capacities / item))) / (num_partially_used_bins + 1)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of the ratio of the bin's current capacity to the item's size and the inverse of the number of partially used bins, considering the variance in the available bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_partially_used_bins = int(np.mean(bins >= item))\\n bin_capacity_variance = np.var(bins)\\n scores = (bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * (num_partially_used_bins + 1) / (bin_capacity_variance + 1)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm uses a weighted score that combines the bin's remaining capacity, the weighted inverse of the number of items in the bin, and the item's size, with the weights adjusted based on the score from the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n base_scores = (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(remaining_capacities / item))) / (num_partially_used_bins + 1)\\n num_items_in_bin = np.floor(bins / item)\\n weights = 1.0 + np.log(num_items_in_bin + 1)\\n scores = base_scores * weights\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to the bin with the highest score calculated by a weighted combination of the ratio of the bin's remaining capacity to the item's size and the inverse of the number of partially used bins, with a bonus for bins where the remaining capacity after assignment is less than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = (1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (num_partially_used_bins + 1)) * (bins > max_capacity / 2)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins considering their remaining capacity, the ratio of the item's size to remaining capacity, number of partially used bins, and variance in the available bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_partially_used_bins = int(np.mean(bins >= item))\\n bin_capacity_variance = np.var(bins)\\n bin_capacity_deviation = np.sum((remaining_capacities - np.mean(remaining_capacities))**2) / np.std(remaining_capacities)\\n scores = remaining_capacities * 0.5 / ((bins / item) - np.floor(bins / item)) * (num_partially_used_bins + 1) / (bin_capacity_variance + 1) * (1.0 + np.square(np.exp(-(bin_capacity_deviation / item))))\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a high remaining capacity and a low number of partially used bins, weighted by the difference between the bin's capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_partially_used_bins = int(np.mean(bins >= item))\\n scores = (bins - item + 1.0 / num_partially_used_bins) * 1.0 / ((bins / item) - np.floor(bins / item)) * np.exp(-(remaining_capacities / item))\\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign item to bins using a linear weighted combination of: a bin's remaining capacity normalized by bin capacity variance, the weighted inverse of the number of items in the bin, and a normal distribution function of remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = (remaining_capacities / np.var(bins)) * 1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 / (np.floor(bins / item) + 1)) * (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the inverse of the number of partially used bins, and 3. the inverse of the square of the difference between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used = remaining_capacities > 0\\n num_partially_used = partially_used.sum()\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used + 1)) + 1.0 / ((bins - item) ** 2 + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted combination of the inverse of the ratio of the bin's remaining capacity to the item's size and the inverse of the difference between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / ((remaining_capacities - (max_capacity - item)) ** 2 + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A weighted combination of fractional-to-integer ratios between item size and bins' remaining capacity and bins' remaining capacity to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if bins.size == 0:\\n return np.array([])\\n score1 = 1.0 / ((bins / item) - np.floor(bins / item))\\n score2 = 1.0 / ((item / bins) - np.floor(item / bins))\\n scores = 0.6 * score1 + 0.4 * score2\\n scores[np.where(bins < item)[0]] = -np.inf\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the inverse of the number of partially used bins, and 3. the inverse of the square of the difference between the bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used_bins + 1)) + 1.0 / ((bins - item) ** 2 + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted combination of the inverse of the ratio of the bin's remaining capacity to the item's size and the inverse of the number of partially used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (np.where(bins == max_capacity, 1, num_partially_used_bins + 1))\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on the inverse of the ratio of the bin's remaining capacity and the item's size, modified by the square root of the bin's total capacity and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n total_capacities = bins\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(total_capacities) + np.sqrt(remaining_capacities)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n weights = (np.sqrt(bins / max_capacity)) * (1.0 + np.exp(-(remaining_capacities / item))) / (np.sqrt(num_items_in_bin + 1))\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n random_numbers = np.random.rand(len(bins))\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(num_partially_used_bins)) * random_numbers\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the remaining capacity of the bin, and 3. the inverse of the number of items that can fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(remaining_capacities) + 1.0 / (remaining_capacities / item + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Introduce a regularization term derived from the bin's remaining capacity to the original scoring function to further differentiate and prioritize the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * 2 / (1 + 1)) - (remaining_capacities + 1e-6) / (max_capacity + 1e-6) * 0.05\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of the ratio of the bin's current capacity to the item's size and the inverse of the number of partially used bins, considering the variance in the available bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = (bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * 2 / (1 + 1)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm uses a weighted score that combines the bin's remaining capacity, the weighted inverse of the number of items in the bin, and the item's size, with the weights adjusted based on the score from the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n base_scores = (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(remaining_capacities / item))) / (num_partially_used_bins + 1)\\n num_items_in_bin = np.floor(bins / item)\\n weights = 1.0 + np.log(num_items_in_bin + 1)\\n scores = base_scores * weights\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Explore rescaling the subtraction component in the original formula to induce flexibility and further discriminate bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n component1 = np.log2((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)))\\n component2 = -1.0 * (remaining_capacities / max_capacity) * (1 - remaining_capacities / max_capacity)\\n component2[remaining_capacities == 0] = 0.0 # Avoid log0 (when bins = item)\\n component2[remaining_capacities / max_capacity == 1.0] = -0.001 # Avoid log0 (when bins are full)\\n scores = 1.3 * component1 + 0.7 * component2\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to the bin with the highest score calculated by a weighted combination of the ratio of the bin's remaining capacity to the item's size and the inverse of the number of partially used bins, with a bonus for bins where the remaining capacity after assignment is less than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n scores = (1.0 / ((bins / item) - np.floor(bins / item)) + 1.0 / (num_partially_used_bins + 1)) * (bins > max_capacity / 2)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins considering their remaining capacity, the ratio of the item's size to remaining capacity, number of partially used bins, and variance in the available bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_partially_used_bins = int(np.mean(bins >= item))\\n bin_capacity_variance = np.var(bins)\\n bin_capacity_deviation = np.sum((remaining_capacities - np.mean(remaining_capacities))**2) / np.std(remaining_capacities)\\n scores = remaining_capacities * 0.5 / ((bins / item) - np.floor(bins / item)) * (num_partially_used_bins + 1) / (bin_capacity_variance + 1) * (1.0 + np.square(np.exp(-(bin_capacity_deviation / item))))\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Revised algorithm: Explore different weight combinations for the two components in the original formula to enhance bin discrimination and adaptability.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n component1 = np.log2((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)))\\n component2 = -1.0 * (remaining_capacities / max_capacity) ** 2 * (1 - remaining_capacities / max_capacity) ** 2\\n component2[remaining_capacities == 0] = 0.0 # Avoid log0 (when bins = item)\\n component2[remaining_capacities / max_capacity == 1.0] = -0.001 # Avoid log0 (when bins are full)\\n scores = 0.6 * component1 + 1.4 * component2\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Introduce the bin's normalization score derived from its remaining capacity to the original scoring function to further differentiate and prioritize the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * 2 / (1 + 1)) - 1.0 * (remaining_capacities / max_capacity) * (1 - remaining_capacities / max_capacity) * 2\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to the bin with the highest score calculated by a weighted combination of the ratio of the bin's remaining capacity to the item's size and the bin's capacity to the total capacity, with a bonus for bins where the remaining capacity after assignment is less than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n total_capacity = sum(bins)\\n scores = (1.0 / ((bins / item) - np.floor(bins / item)) + bins / total_capacity) * (bins > max_capacity / 2)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins based on a weighted sum of the inverse of the ratio of the bin's remaining capacity to the item's size, the square root of the bin's total capacity, and the square of the inverse of the number of items that can fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_bins_can_fit = np.floor(bins / item)\\n scores = 1.0 / ((bins / item) - num_bins_can_fit) + np.sqrt(bins) + 1.0 / (num_bins_can_fit + 1)**2\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the bin's maximum capacity, and 3. the square of the inverse of the number of items that can fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacities = bins + item\\n remaining_capacities = maximum_capacities - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(maximum_capacities) + 1.0 / (remaining_capacities / item + 1)**2\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Computes a score for each bin based on its capacity modulation, weighted by its remaining capacity and penalized for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Computes a score for each bin based on its capacity and the item size, modulated by a function of the remaining capacity and penalized for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item)**2 * (1.0 / ((bins / item) - np.floor(bins / item)))) * (remaining_capacities/max_capacity)**0.5\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n weights = (np.sqrt(bins / max_capacity)) * (1.0 + np.exp(-(remaining_capacities / item))) / (np.sqrt(num_items_in_bin + 1))\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm incorporates a penalty term that discourages assigning items to bins with excessively large remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item))) - 0.1 * (bins - max_capacity)\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n random_numbers = np.random.rand(len(bins))\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(num_partially_used_bins)) * random_numbers\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm combines the concepts of bin compactness and item-bin size ratio weighting to determine optimal bin assignment, ensuring efficient packing while accommodating the item's specific size constraints.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n weights = (np.sqrt(bins / max_capacity)) * (1.0 + np.exp(-(remaining_capacities / item))) / (np.sqrt(num_items_in_bin + 1))\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n scores += 0.5 * (1.0 - (num_items_in_bin) / (bins / item))\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the remaining capacity of the bin, and 3. the inverse of the number of items that can fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(remaining_capacities) + 1.0 / (remaining_capacities / item + 1)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Revise the regularization term to suppress the over-optimization caused by the excessive preference for bins with relatively smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * 2 / (1 + 1)) - (remaining_capacities + 1e-6) / (max_capacity + 1e-6) * 0.1\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of the ratio of the bin's current capacity to the item's size, the inverse of the number of partially used bins, and the variance in the available bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins = bins - item\\n scores = (bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * 2 / (1 + 1)\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use a combination of exponential and a power function to penalize bins that are full or nearly full while rewarding bins with higher remaining capacities to drive item assignment to bins with ample space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = (1.0 + np.exp(-(remaining_capacities / max_capacity))) ** 2 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 1.5\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with the least remaining capacity while maintaining a normalized difference condition to avoid premature bin utilization and encourage balanced bin filling.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1.0 / ((bins / item) - np.floor(bins / item))) * (bins / item) / np.max((bins / item), axis=0)\\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of 1. the inverse of the ratio of the bin's remaining capacity to the item's size, 2. the square root of the remaining capacity of the bin, and 3. the inverse of the number of items that can fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) + np.sqrt(remaining_capacities)\\n scores[bins < item] = -np.inf\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Explore rescaling the subtraction component in the original formula to induce flexibility and further discriminate bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n component1 = np.log2((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)))\\n component2 = -1.0 * (remaining_capacities / max_capacity) * (1 - remaining_capacities / max_capacity)\\n component2[remaining_capacities == 0] = 0.0 # Avoid log0 (when bins = item)\\n component2[remaining_capacities / max_capacity == 1.0] = -0.001 # Avoid log0 (when bins are full)\\n scores = 1.3 * component1 + 0.7 * component2\\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Computes a score for each bin based on its capacity modulation, weighted by its remaining capacity and penalized for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Minimize the number of bins by scoring bins based on their capacity and utilization ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n if bins[bins.shape[0]-1] >= max_capacity:\\n bins[bins.shape[0]-1] = max_capacity - item\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n weights = (np.sqrt(bins / max_capacity)) * (1.0 + np.exp(-(remaining_capacities / item))) / (np.sqrt(num_items_in_bin + 1))\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm incorporates a penalty term that discourages assigning items to bins with excessively large remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item))) - 0.1 * (bins - max_capacity)\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 1.5 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n random_numbers = np.random.rand(len(bins))\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(num_partially_used_bins)) * random_numbers\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.ceil(bins / item)\\n weights = 1.0\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on the weighted sum of the inverse of bin utilization and the product of the bin's maximum capacity and the rate of its utilization to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((bins - item) / item) / ((bins / item) - np.floor(bins / item)) * (bins * max_capacity) / (bins * item)\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Modify the original code by replacing the regularization term with a revised one that considers both the remaining capacity and the maximum capacity of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * 2 / (1 + 1)) - (remaining_capacities + 1e-6) / (bins + 1e-6) * 0.1\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted combination of the ratio of the bin's current capacity to the item's size, the inverse of the number of partially used bins, and the variance in the available bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins = bins - item\\n scores = (bins / item) * 1.0 / ((bins / item) - np.floor(bins / item)) * 2 / (1 + 1)\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a decaying exponential function of their remaining capacity, while considering the item size to prevent premature bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item)**2 * np.exp(-(bins - item) / np.max(bins))\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with higher remaining capacity by incorporating a logarithmic function that assigns higher scores to bins with greater capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities / item ** 2\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity by scoring them exponentially based on their capacity ratio and penalizing bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp(remaining_capacities / max_capacity)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Computes a score for each bin based on its capacity modulation, weighted by its remaining capacity and penalized for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Minimize the number of bins by scoring bins based on their capacity and utilization ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n if bins[bins.shape[0]-1] >= max_capacity:\\n bins[bins.shape[0]-1] = max_capacity - item\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm introduces a novel scoring mechanism that considers the current bin capacity and the total remaining capacity of all feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n total_remaining_capacity = np.sum(remaining_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + remaining_capacities / (max_capacity - remaining_capacities)) * (1.0 + remaining_capacities / total_remaining_capacity)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the cubic root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) ** 2 * (bins ** (1/3)) / (max_capacity ** (1/3))\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm incorporates a penalty term that discourages assigning items to bins with excessively large remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item))) - 0.1 * (bins - max_capacity)\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 1.5 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n random_numbers = np.random.rand(len(bins))\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(num_partially_used_bins)) * random_numbers\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.ceil(bins / item)\\n weights = 1.0\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (bins / item - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Iteratively assign items to bins based on the ratio of bin capacity to item size, with the ratio penalized for bins with higher utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * (1.0 / ((bins / item) - np.floor(bins / item)) + 0.5)\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with higher remaining capacity by incorporating a logarithmic function that assigns higher scores to bins with greater capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.log(max_capacity / remaining_capacities) * remaining_capacities / item ** 2\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the strength of the logarithmic component with the power of the times the bin is used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.log(bins) ** (np.arange(len(bins)) ** 1)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity and the inverse of the square root of the number of items in the bin, with weights adjusted by the square of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (np.log(num_items_in_bin + 1) + 1) * remaining_capacities * (bins ** 2) / ((bins / item) - np.floor(bins / item)) ** 2 * 1.0 / (max_capacity ** 2)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Bins with higher score means that there is a higher probability of being assigned to the item.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / item)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm evaluates the bin score based on a weighted combination of the bin capacity and the ratio of the item size to the bin capacity, while considering the current remaining capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * (1.0 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))) + (max_capacity - bins) / (max_capacity - item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Uses an exponential function to penalize bins with low remaining capacity to encourage utilization of bins with higher capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 / (1.0 + np.exp(-(remaining_capacities / max_capacity)))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have the largest remaining capacity, while penalizing bins that have been partially used, based on a normalized difference between the bin's current capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher remaining capacity by scoring them exponentially based on their capacity ratio and penalizing bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 * np.exp(remaining_capacities / max_capacity)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Computes a score for each bin based on its capacity modulation, weighted by its remaining capacity and penalized for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (remaining_capacities/max_capacity) ** 0.5\\n scores[remaining_capacities < 0] = -np.inf\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 2 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(bins / item))))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Minimize the number of bins by scoring bins based on their capacity and utilization ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n if bins[bins.shape[0]-1] >= max_capacity:\\n bins[bins.shape[0]-1] = max_capacity - item\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved algorithm introduces a novel scoring mechanism that considers the current bin capacity and the total remaining capacity of all feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n total_remaining_capacity = np.sum(remaining_capacities)\\n scores = ((bins / item) * 1.0 / ((bins / item) - np.floor(bins / item))) * (1.0 + remaining_capacities / (max_capacity - remaining_capacities)) * (1.0 + remaining_capacities / total_remaining_capacity)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the cubic root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) ** 2 * (bins ** (1/3)) / (max_capacity ** (1/3))\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm incorporates a penalty term that discourages assigning items to bins with excessively large remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.exp(-(bins / item))) - 0.1 * (bins - max_capacity)\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Reassign bins with lower remaining capacity with negative scores to prioritize their utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = 1.0 / ((bins / item) - np.floor(bins / item)) * (bins / item) ** 1.5 + np.where(remaining_capacities <= (max_capacity / 10), -1.0, 0.0)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm adds a randomization step to the previous algorithm to enhance its robustness and efficiency.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n partially_used_bins = np.where(np.logical_and(bins >= item, bins < max_capacity))[0]\\n num_partially_used_bins = len(partially_used_bins)\\n random_numbers = np.random.rand(len(bins))\\n scores = (bins - item) * 0.5 / ((bins / item) - np.floor(bins / item)) * (1.0 + np.square(np.exp(-(remaining_capacities / item)))) / (1.0 + np.sqrt(num_partially_used_bins)) * random_numbers\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.ceil(bins / item)\\n weights = 1.0\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item)) * weights\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score, calculated by a weighted combination of the bin's remaining capacity, the inverse of the square root of the number of items in the bin, and the item's size, with weights adjusted by the square root of the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n num_items_in_bin = np.floor(bins / item)\\n scores = (0.5 + 0.5 * np.log(num_items_in_bin + 1)) * (bins - item) * 1.0 / ((bins / item) - np.floor(bins / item))\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to bins with scores based on the remaining capacity but also incorporate the item size, giving preference to bins that can accommodate the item without leaving too much empty space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_bin = np.max(bins)\\n available_space = bins - item\\n scores[available_space >= 0] = max_bin - (available_space[available_space >= 0] * item / max_bin)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by calculating the sum of their normalized capacity with the normalized size of the item and the square root of the bin index, while penalizing bins with less remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins >= item, (1 - bins / max_capacity) + (item / max_capacity) + np.sqrt(np.arange(len(bins))), -np.inf)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins for an item by scoring based on available bin space, prioritizing bins with a difference between maximum and mean bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins.mean()) - (bins - item))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate each bin's score by subtracting the bin's current load from the maximum capacity of the bin and then multiplying by the reciprocal of its load plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity - bin_capacity) / (bin_capacity + 1)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins >= item] = 1\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns items to bins based on a score calculated as a function of the bin's remaining capacity, the item's size, and the difference between the bin's capacity and the item's size, with some randomness added to break ties.\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_bin = np.max(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity >= 0] = (\\n remaining_capacity[remaining_capacity >= 0]\\n / (item * max_bin)\\n + (bins[remaining_capacity >= 0] - item) / max_bin\\n + random.random() / 100\\n ) # Calculate score based on remaining capacity, item size, and bin capacity\\n return scores\",\n \"objective\": 0.04487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by multiplying the bin's rest capacity with the item's size and then weighting it by a factor that decreases exponentially with the bin's index. Weighting factor ranging from 0 to 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=-np.inf)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n diff = bin_capacity - item\\n scores[i] = diff * 0.5 ** i\\n return scores\",\n \"objective\": 0.04829,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with less remaining capacity and uses a cosine function to calculate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.cos(np.pi * (1 - remaining_capacity[remaining_capacity > 0] / item)) # Cosine decay score\\n return scores\",\n \"objective\": 0.0484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign bins inversely proportional to their remaining capacity to maximize space utilization and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins.max() / (bins - item)\\n scores[bins <= item] = -np.inf\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel algorithm that assigns scores to bins based on the ratio of the item's size to the bin's capacity, with a higher score for bins with a lower ratio and a penalty for bins that have been used multiple times.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores = np.where(remaining_capacity > 0, item / remaining_capacity - 0.1 * np.arange(len(bins)), -np.inf)\\n return scores\",\n \"objective\": 0.05081,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Scores bins linearly based on their remaining capacity and index, applies a capacity penalty for full bins, and scales scores based on item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n capacity_penalty = 1 - (bin_capacity / max_capacity)\\n index_penalty = np.exp(-i / len(bins))\\n score_ratio = (bin_capacity - item) / max_capacity\\n scaled_score = score_ratio * capacity_penalty * index_penalty\\n scores[i] = scaled_score * item * bin_capacity / max_capacity\\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use a score that is the product of the difference between the bin's remaining capacity and the current item's size, and the reciprocal of the bin's remaining capacity, with a lower bound of zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores = np.where(remaining_capacity > 0, remaining_capacity * (1/remaining_capacity), 0)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm changes the scoring method to give higher priority to bins with less remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item) * (1 - bins[i] / max_capacity)\\n\\n return scores\",\n \"objective\": 0.05765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the item's size, the remaining capacity of the bin, the maximum capacity of the bin, and the average remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n avg_remaining_capacity = np.mean(bins - item)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (bins[i] - item) / (max_capacity - avg_remaining_capacity)\\n\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: This algorithm calculates the score for each bin by multiplying the ratio of the bin's rest capacity to the item's size with a weighting factor that decreases exponentially with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n ratio = bin_capacity / item\\n weighting_factor = np.exp(-i / len(bins))\\n scores[i] = ratio * weighting_factor\\n return scores\",\n \"objective\": 0.05836,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Assign an item to a bin with the maximum score, calculated as a weighted sum of the square of bin capacity, bin index, distance to the center, and number of items fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.min(bins / item)\\n scores = 3 * (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + 2 * np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n number_items_in_bin = np.floor(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + number_items_in_bin + np.arange(len(bins)) - np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the square of the difference between the bin's capacity and the item size, and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n squared_remaining_capacities = normalized_remaining_capacities ** 2\\n squared_distances_to_the_item = (((bins - item) / item) ** 2) / ((bins - item) / item).max()\\n scores = squared_remaining_capacities / squared_remaining_capacities.min() + squared_distances_to_the_item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores bins with a weighted sum of the square of bin remaining capacity, bin index, distance to the bin center, and number of items fit into the bin, but the weights are different.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.min(bins / item)\\n scores = 4 * (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) + 1.5 * np.sqrt(distances_to_the_center) + 0.5 * num_fits\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, bin index, a random number, distance to the center, and number of items fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.random.uniform(0, 1, len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as the square root of the sum of the weighted square of the bin's current capacity and the arctangent of the ratio of the bin's capacity to the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\nfrom math import atan, sqrt\\n\\ndef score(item, bins):\\n weighted_capacities = np.sqrt(((bins - item) ** 2) / (bins - item).min())\\n ratios = bins / item\\n scores = weighted_capacities + np.arctan(ratios) + np.arange(len(bins)) + np.sqrt(np.abs(bins - np.mean(bins)) / np.std(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates a weighted sum of the square of bin capacity, bin index, distance to the average, and number of items fit into the bin, considering the ratio between bin capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = normalized_remaining_capacities ** 2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + (bins / item) ** 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 0.9)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n number_items_in_bin = np.floor(bins / item) * 0.75\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + number_items_in_bin + np.arange(len(bins)) - np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, bin index, a random number, distance to the center, and number of items fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = np.where(bins >= item, 1, 0)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.random.uniform(0, 1, len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the highest score, calculated as a cubed sum of a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the distance to the center of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) + np.abs(bins - np.mean(bins))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted combination of the bin's remaining capacity that is penalized by the number of item that can be fit into the bin and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities - (normalized_remaining_capacities / np.sum(normalized_remaining_capacities)) * num_fits)**2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, and the score from the previous step.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) // 2 + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of the weighted score of normalized remaining capacity, the reciprocal of the remaining capacity, and the square root of the remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([4, 2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, the square root of the bin's capacity, and the reciprocal of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) // 2 + np.arange(len(bins)) + np.sqrt(bins) + 1 / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score defined as a weighted sum of the bin's rest capacity to the power of 3, the ratio of the bin's rest capacity to the item size, the bin's index, the bin's capacity divided by the item size, the ratio of the number of items that can fit into the bin to the number of items that can fit in the best bin, and the ratio of the square of the bin's current capacity to the square of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n num_fits = bins / item / np.max(bins / item)\\n scores = (bins**3) / (bins**3).max() + normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins)) + normalized_capacities / normalized_capacities.min() + num_fits + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a current item to the bin with the maximum score and updates the rest capacity of the bins, until all items are assigned. The score is calculated based on the bin's rest capacity, the difference between the bin's rest capacity and the item size, the number of times the bin has been used, and the square of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n used_bins_scores = np.arange(len(bins))\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + used_bins_scores + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Assign item to the bin with the maximum score after calculating the score as a weighted sum of score calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the bin's capacity to the power of 3, a Gaussian function of the bin's capacity, the number of items that fit into the bin, and the reciprocal of the variance of the bin's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins - item) / item + np.exp(-(bins - bins.mean()) ** 2 / (2 * bins.std() ** 2)) + np.arange(len(bins)) + np.sqrt(bins) + 1 / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1) + np.random.uniform(0, 1, len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and the inverse of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n num_fits = bins / item / np.max(bins / item)\\n normalized_bin_indices = np.minimum(bins / item, 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1) + num_fits - normalized_bin_indices\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins with a weighted sum of the bin\\u2019s current height, capacity, bin index, and number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n capacity_factors = (bins / bins.max()) ** 2\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * capacity_factors + 0.5 * np.arange(len(bins)) + np.floor(bins / item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1) / np.max((bins - item) / item)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n number_items_in_bin = np.floor(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + number_items_in_bin + np.arange(len(bins)) - np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the bin's capacity, the number of times the bin has been used, the difference between the bin's capacity and the item size, the distance to the center of bins, and the number of items that fit into the bin, but the weights are different.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = np.floor(bins / item) * 0.5\\n scores = (normalized_remaining_capacities ** 2.5) / normalized_remaining_capacities.min() + 0.75 * np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores bins with a weighted sum of the square of bin remaining capacity, bin index, distance to the bin center, and number of items fit into the bin, but the weights are different.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.min(bins / item)\\n scores = 4 * (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) + 1.5 * np.sqrt(distances_to_the_center) + 0.5 * num_fits\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted combination of the bin's remaining capacity that is penalized by the number of item that can be fit into the bin and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item\\n scores = (normalized_remaining_capacities - (normalized_remaining_capacities / np.sum(normalized_remaining_capacities)) * num_fits)**2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, bin index, a random number, distance to the center, and number of items fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.random.uniform(0, 1, len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, bin index, bin capacity divided by item size, and number of items fit into the bin, and use an exponential function to amplify the difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = np.where(bins >= item, 1, 0)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + (bins / item) + num_fits\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates a weighted sum of the square of bin capacity, bin index, distance to the average, and number of items fit into the bin, considering the ratio between bin capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = normalized_remaining_capacities ** 2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + (bins / item) ** 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 0.9)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n number_items_in_bin = np.floor(bins / item) * 0.75\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + number_items_in_bin + np.arange(len(bins)) - np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, bin index, a random number, distance to the center, and number of items fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = np.where(bins >= item, 1, 0)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.random.uniform(0, 1, len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the highest score, calculated as a cubed sum of a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the distance to the center of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) + np.abs(bins - np.mean(bins))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Assign item to the bin with the maximum score after calculating the score as a weighted sum of score calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the bin's capacity to the power of 3, a Gaussian function of the bin's capacity, the number of items that fit into the bin, and the reciprocal of the variance of the bin's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins - item) / item + np.exp(-(bins - bins.mean()) ** 2 / (2 * bins.std() ** 2)) + np.arange(len(bins)) + np.sqrt(bins) + 1 / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with sufficient remaining capacity and a balanced number of items, deterring bins with excessive or minimal items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n items_in_bin = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - (items_in_bin - 1) ** 2 / (items_in_bin - 1).max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1) + np.random.uniform(0, 1, len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the ratio of item size and remaining bin capacity while considering the bin's current height, index, and its capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n capacity_factors = (bins - item) / (bins - item).max()\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * capacity_factors + 0.5 * np.arange(len(bins)) + np.floor(bins / item) + 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins with a weighted sum of the bin\\u2019s current height, capacity, bin index, and number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n capacity_factors = (bins / bins.max()) ** 2\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * capacity_factors + 0.5 * np.arange(len(bins)) + np.floor(bins / item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1) / np.max((bins - item) / item)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved Score Function: We adjust parameter settings in the existing score function to prioritize bins with ample remaining capacity, proximity to an average bin size, and a high number of items fit to minimize used bin count.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.min(bins / item)\\n scores = 6 * (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + 1 * np.arange(len(bins)) + 2 * distances_to_the_center + 1 * num_fits\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n number_items_in_bin = np.floor(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + number_items_in_bin + np.arange(len(bins)) - np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the bin's capacity, the number of times the bin has been used, the difference between the bin's capacity and the item size, the distance to the center of bins, and the number of items that fit into the bin, but the weights are different.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = np.floor(bins / item) * 0.5\\n scores = (normalized_remaining_capacities ** 2.5) / normalized_remaining_capacities.min() + 0.75 * np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores bins with a weighted sum of the square of bin remaining capacity, bin index, distance to the bin center, and number of items fit into the bin, but the weights are different.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.min(bins / item)\\n scores = 4 * (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) + 1.5 * np.sqrt(distances_to_the_center) + 0.5 * num_fits\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted combination of the bin's remaining capacity that is penalized by the number of item that can be fit into the bin and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item\\n scores = (normalized_remaining_capacities - (normalized_remaining_capacities / np.sum(normalized_remaining_capacities)) * num_fits)**2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins with a weighted sum of the square of bin capacity, bin index, and distance to the bin center, and number of items fit into the bin, while using logarithms to magnify the differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = np.where(bins >= item, 1, 0)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.log(distances_to_the_center + 1) + np.log(num_fits + 1)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, bin index, bin capacity divided by item size, and number of items fit into the bin, and use an exponential function to amplify the difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = np.where(bins >= item, 1, 0)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + (bins / item) + num_fits\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates a weighted sum of the square of bin capacity, bin index, distance to the average, and number of items fit into the bin, considering the ratio between bin capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = normalized_remaining_capacities ** 2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + (bins / item) ** 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Assign item to the bin with the maximum score after calculating the score as a weighted sum of score calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the bin's capacity to the power of 3, a Gaussian function of the bin's capacity, the number of items that fit into the bin, and the reciprocal of the variance of the bin's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins - item) / item + np.exp(-(bins - bins.mean()) ** 2 / (2 * bins.std() ** 2)) + np.arange(len(bins)) + np.sqrt(bins) + 1 / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with sufficient remaining capacity and a balanced number of items, deterring bins with excessive or minimal items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n items_in_bin = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - (items_in_bin - 1) ** 2 / (items_in_bin - 1).max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with sufficient remaining capacity and a balanced number of items, while deterring bins with minimal items and preferring bins with average items, while penalizing bins with excessive items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n items_in_bin = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + (bin_item_ratio - 1) ** 2 / (bin_item_ratio - 1).max() - (items_in_bin - 1) ** 2 / (items_in_bin - 1).max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the ratio between the current height of a bin and the item size in addition to the difference between the item size and the remaining capacity of a bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_height_item_ratio = bins / item\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.exp(-bin_height_item_ratio) + np.floor(bins / item * 0.75) + 0.75 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins with a weighted sum of the bin\\u2019s current height, capacity, bin index, and number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n capacity_factors = (bins / bins.max()) ** 2\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * capacity_factors + 0.5 * np.arange(len(bins)) + np.floor(bins / item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute a weighted sum of the bin's current size, the bin's capacity to the power of 4, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1) / np.max((bins - item) / item)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Improved Score Function: We adjust parameter settings in the existing score function to prioritize bins with ample remaining capacity, proximity to an average bin size, and a high number of items fit to minimize used bin count.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.min(bins / item)\\n scores = 6 * (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + 1 * np.arange(len(bins)) + 2 * distances_to_the_center + 1 * num_fits\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the geometric mean between the bin remaining capacity and itself to the power of 3, the bin index, and the bin's remaining capacity divided by its capacity to power of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (np.sqrt(normalized_remaining_capacities * (normalized_remaining_capacities ** 3))) / (normalized_remaining_capacities.min() ** 2) + np.arange(len(bins)) + bins / bins.min() ** 2\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bins with sufficient capacity to accommodate the current item, assign the item to the bin with the maximum score estimated as a weighted sum of the bin's current capacity, the number of items that could fit into the bin, and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.min() + 0.3 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores bins with a weighted sum of the square of bin remaining capacity, bin index, distance to the bin center, and number of items fit into the bin, but the weights are different.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.min(bins / item)\\n scores = 4 * (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) + 1.5 * np.sqrt(distances_to_the_center) + 0.5 * num_fits\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted combination of the bin's remaining capacity that is penalized by the number of item that can be fit into the bin and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item\\n scores = (normalized_remaining_capacities - (normalized_remaining_capacities / np.sum(normalized_remaining_capacities)) * num_fits)**2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to a bin with the highest score calculated as a weighted combination of the remaining capacity, the bin's index, the count of items that fit into the bin, a constant, and the logarithm of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item\\n scores = (\\n normalized_remaining_capacities\\n - (normalized_remaining_capacities / np.sum(normalized_remaining_capacities)) * num_fits\\n ) ** 2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits * 0.1 + np.log1p(bins / item) * 0.5\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins with a weighted sum of the square of bin capacity, bin index, and distance to the bin center, and number of items fit into the bin, while using logarithms to magnify the differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = np.where(bins >= item, 1, 0)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.log(distances_to_the_center + 1) + np.log(num_fits + 1)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) / normalized_remaining_capacities.mean()\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with sufficient remaining capacity and a balanced number of items, deterring bins with excessive or minimal items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n items_in_bin = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - (items_in_bin - 1) ** 2 / (items_in_bin - 1).max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the bin's current size, the bin's capacity to the power of 3, the bin's remaining capacity to the power of 2, the bin's available spaces to the power of 2, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins ** 3) / bins.max() ** 3 + (available_spaces ** 2) / available_spaces.max() ** 2 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the ratio between the current height of a bin and the item size in addition to the difference between the item size and the remaining capacity of a bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_height_item_ratio = bins / item\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.exp(-bin_height_item_ratio) + np.floor(bins / item * 0.75) + 0.75 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm computes a weighted sum of the bin's current size, the bin's capacity to the power of 2, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 2) / bins.max() ** 2 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.tanh((bins - item) / item)\\n distances_to_the_center = np.tanh(np.abs(bins - np.mean(bins)) / np.std(bins))\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity, the bin's capacity to the power of 4, the bin's position in the list, and the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute a weighted sum of the bin's current size, the bin's capacity to the power of 4, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as a combination of its remaining capacity, the ratio of its current height to the maximum height, and the index of the bin in the list, where higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 2 + 0.25 * (bins / item) ** 2 + 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1) / np.max((bins - item) / item)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with sufficient remaining capacity and a balanced distribution of items but penalizing higher indexed bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + (bin_item_ratio - 1) ** 2 / (bin_item_ratio - 1).max() - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the geometric mean between the bin remaining capacity and itself to the power of 3, the bin index, and the bin's remaining capacity divided by its capacity to power of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (np.sqrt(normalized_remaining_capacities * (normalized_remaining_capacities ** 3))) / (normalized_remaining_capacities.min() ** 2) + np.arange(len(bins)) + bins / bins.min() ** 2\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bins with sufficient capacity to accommodate the current item, assign the item to the bin with the maximum score estimated as a weighted sum of the bin's current capacity, the number of items that could fit into the bin, and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.min() + 0.3 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute a weighted sum of the bin's current size, the bin's capacity to the power of 3, the bin's remaining capacity to the power of 2, the cube root of the number of times the bin has been used, the cube root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins ** 3) / bins.max() ** 3 + np.cbrt(bins) + np.cbrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) / normalized_remaining_capacities.mean()\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a weighted sum of the normalized remaining capacities of feasible bins, the square root of the cumulative distance to the center with decay, the square root of the bin index, and the natural logarithm of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1) / np.max((bins - item) / item)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1) + np.log(bins)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Promote bins with a large number of items and penalize bins with a small number of items while considering the remaining capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.75 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.75 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the ratio between the current height of a bin and the item size in addition to the difference between the item size and the remaining capacity of a bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_height_item_ratio = bins / item\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.exp(-bin_height_item_ratio) + np.floor(bins / item * 0.75) + 0.75 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm computes a weighted sum of the bin's current size, the bin's capacity to the power of 2, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 2) / bins.max() ** 2 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.tanh((bins - item) / item)\\n distances_to_the_center = np.tanh(np.abs(bins - np.mean(bins)) / np.std(bins))\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity, the bin's capacity to the power of 4, the bin's position in the list, and the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute a weighted sum of the bin's current size, the bin's capacity to the power of 4, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as a combination of its remaining capacity, the ratio of its current height to the maximum height, and the index of the bin in the list, where higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 2 + 0.25 * (bins / item) ** 2 + 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, cumulative distance to the center with decay, square root of the number of times the bin has been used, and a random number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1) / np.max((bins - item) / item)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n cumulative_distances_to_the_center = np.cumsum(distances_to_the_center) * np.exp(-np.arange(len(bins)) / len(bins))\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + cumulative_distances_to_the_center + np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * bins / bins.max() ** 2.5 + remaining_capacities ** 3 / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the geometric mean between the bin remaining capacity and itself to the power of 3, the bin index, and the bin's remaining capacity divided by its capacity to power of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (np.sqrt(normalized_remaining_capacities * (normalized_remaining_capacities ** 3))) / (normalized_remaining_capacities.min() ** 2) + np.arange(len(bins)) + bins / bins.min() ** 2\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bins with sufficient capacity to accommodate the current item, assign the item to the bin with the maximum score estimated as a weighted sum of the bin's current capacity, the number of items that could fit into the bin, and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.min() + 0.3 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) / normalized_remaining_capacities.mean()\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The algorithm calculates the score of each bin as a combination of the remaining capacity, the negative of the bin's usage factor (i.e., the proportion of the bin that is already full), and the negative index of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() - 0.5 * bins / bins.max() - 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Promote bins with a large number of items and penalize bins with a small number of items while considering the remaining capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.75 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.75 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Consider the ratio between the current height of a bin and the item size in addition to the difference between the item size and the remaining capacity of a bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_height_item_ratio = bins / item\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.exp(-bin_height_item_ratio) + np.floor(bins / item * 0.75) + 0.75 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm computes a weighted sum of the bin's current size, the bin's capacity to the power of 2, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 2) / bins.max() ** 2 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of bins as a weighted sum of a normalized score based on the bin's capacity, a score based on the bin's position, a score based on the bin's height relative to the item size, and a score based on the bin's utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_height_item_ratio = bins / item\\n bin_utilization = bins - np.maximum((bins - item), 0)\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + (bin_height_item_ratio ** 2) / bin_height_item_ratio.max() ** 2 + 0.5 * np.arange(len(bins)) + 0.25 * np.log(bin_utilization + 1)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity, the bin's capacity to the power of 4, the bin's position in the list, and the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute a weighted sum of the bin's current size, the bin's capacity to the power of 4, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * bins / bins.max() ** 2.5 + remaining_capacities / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm determines the score of a bin based on the following criteria: the bin's remaining capacity, the bin's position, the bin's capacity, and the number of times the bin has been used. The score is calculated as the sum of these factors, each weighted by a different power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins / bins.max()) ** 3 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * bins / bins.max() ** 2.5 + remaining_capacities ** 3 / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the geometric mean between the bin remaining capacity and itself to the power of 3, the bin index, and the bin's remaining capacity divided by its capacity to power of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (np.sqrt(normalized_remaining_capacities * (normalized_remaining_capacities ** 3))) / (normalized_remaining_capacities.min() ** 2) + np.arange(len(bins)) + bins / bins.min() ** 2\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bins with sufficient capacity to accommodate the current item, assign the item to the bin with the maximum score estimated as a weighted sum of the bin's current capacity, the number of items that could fit into the bin, and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.min() + 0.3 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) / normalized_remaining_capacities.mean()\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The algorithm calculates the score of each bin as a combination of the remaining capacity, the negative of the bin's usage factor (i.e., the proportion of the bin that is already full), and the negative index of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() - 0.5 * bins / bins.max() - 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Promote bins with a large number of items and penalize bins with a small number of items while considering the remaining capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.75 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.75 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the sum of its current height and the maximum height, the item size, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.25 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins + bins.max()) / bins.max() - 0.25 * np.arange(len(bins)) + 0.25 * item / bins.max()\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm computes a weighted sum of the bin's current size, the bin's capacity to the power of 2, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 2) / bins.max() ** 2 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the score of each bin as a combination of its remaining capacity, the ratio of its remaining capacity to its original capacity, and the negative index of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (normalized_remaining_capacities / (bins / bins.max())) - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity, the bin's capacity to the power of 4, the bin's position in the list, and the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute a weighted sum of the bin's current size, the bin's capacity to the power of 4, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 / bins ** 2 + remaining_capacities / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm determines the score of a bin based on the following criteria: the bin's remaining capacity, the bin's position, the bin's capacity, and the number of times the bin has been used. The score is calculated as the sum of these factors, each weighted by a different power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins / bins.max()) ** 3 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * bins / bins.max() ** 2.5 + remaining_capacities ** 3 / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity to the power of 2, the bin's position in the list, the bin's capacity to the power of 3, and the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + (bins ** 3) / bins.max() ** 3 + remaining_capacities\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bins with sufficient capacity to accommodate the current item, assign the item to the bin with the maximum score estimated as a weighted sum of the bin's current capacity, the number of items that could fit into the bin, and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.min() + 0.3 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) / normalized_remaining_capacities.mean()\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The algorithm calculates the score of each bin as a combination of the remaining capacity, the negative of the bin's usage factor (i.e., the proportion of the bin that is already full), and the negative index of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() - 0.5 * bins / bins.max() - 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Promote bins with a large number of items and penalize bins with a small number of items while considering the remaining capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.75 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.75 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the sum of its current height and the maximum height, the item size, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.25 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins + bins.max()) / bins.max() - 0.25 * np.arange(len(bins)) + 0.25 * item / bins.max()\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.6 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.6 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, remaining capacity, and its inverse index in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * (bins.size - np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity, the bin's capacity to the power of 4, the bin's position in the list, and the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute a weighted sum of the bin's current size, the bin's capacity to the power of 4, the bin's remaining capacity to the power of 3, the square root of the number of times the bin has been used, the square root of the number of empty spaces in the bin, and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n available_spaces = bins - np.maximum((bins - item), 0)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins ** 4) / bins.max() ** 4 + np.sqrt(bins) + np.sqrt(available_spaces) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores bins based on their capacity, considering the item's size, bin's original capacity, and the bin's position, with a logarithmic component and a weighted sum of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (normalized_remaining_capacities / (bins / bins.max())) - 0.25 * np.arange(len(bins)) + np.log(bins / bins.max()) + np.array([(item / bins[i])**3 for i in range(0, len(bins))])\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 / bins ** 2 + remaining_capacities / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm determines the score of a bin based on the following criteria: the bin's remaining capacity, the bin's position, the bin's capacity, and the number of times the bin has been used. The score is calculated as the sum of these factors, each weighted by a different power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins / bins.max()) ** 3 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * bins / bins.max() ** 2.5 + remaining_capacities ** 3 / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity to the power of 2, the bin's position in the list, the bin's capacity to the power of 3, and the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + (bins ** 3) / bins.max() ** 3 + remaining_capacities\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bins with sufficient capacity to accommodate the current item, assign the item to the bin with the maximum score estimated as a weighted sum of the bin's current capacity, the number of items that could fit into the bin, and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.min() + 0.3 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) / normalized_remaining_capacities.mean()\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The algorithm calculates the score of each bin as a combination of the remaining capacity, the negative of the bin's usage factor (i.e., the proportion of the bin that is already full), and the negative index of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() - 0.5 * bins / bins.max() - 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * remaining_capacities / remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Promote bins with a large number of items and penalize bins with a small number of items while considering the remaining capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.75 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.75 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a weighted sum of its remaining capacity, the inverse of its index in the list, and the difference between its current height and the maximum height.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.25 * normalized_remaining_capacities / normalized_remaining_capacities.min() - 0.25 * np.arange(len(bins)) + 0.25 * (bins - bins.max()) / bins.max()\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.6 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.6 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, remaining capacity, and its inverse index in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * (bins.size - np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as a combination of the bin's normalized remaining capacity, the square root of the bin's current height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * np.sqrt(bins / bins.max()) - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score of each bin is a weighted sum of a high power of its remaining capacity to promote empty bins, a low power of its current height to penalize full bins, and its index in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 5) / remaining_capacities.min() - (bins / bins.max()) ** 0.2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores bins based on their capacity, considering the item's size, bin's original capacity, and the bin's position, with a logarithmic component and a weighted sum of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (normalized_remaining_capacities / (bins / bins.max())) - 0.25 * np.arange(len(bins)) + np.log(bins / bins.max()) + np.array([(item / bins[i])**3 for i in range(0, len(bins))])\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 / bins ** 2 + remaining_capacities / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm determines the score of a bin based on the following criteria: the bin's remaining capacity, the bin's position, the bin's capacity, and the number of times the bin has been used. The score is calculated as the sum of these factors, each weighted by a different power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins / bins.max()) ** 3 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * bins / bins.max() ** 2.5 + remaining_capacities ** 3 / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity to the power of 2, the bin's position in the list, the bin's capacity to the power of 3, and the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + (bins ** 3) / bins.max() ** 3 + remaining_capacities\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Considering bins with sufficient capacity to accommodate the current item, assign the item to the bin with the maximum score estimated as a weighted sum of the bin's current capacity, the number of items that could fit into the bin, and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.min() + 0.3 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = (normalized_remaining_capacities**2) / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate each bin's score by multiplying the bin's current load by the reciprocal of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate each bin's score by subtracting the bin's current load from the maximum capacity of the bin and then multiplying by the reciprocal of its load plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = 1000 # Replace with learned parameter or constant\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity - bin_capacity) / (bin_capacity + 1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to bins with scores based on the remaining capacity but also incorporate the item size, giving preference to bins that can accommodate the item without leaving too much empty space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_bin = np.max(bins)\\n available_space = bins - item\\n scores[available_space >= 0] = max_bin - (available_space[available_space >= 0] * item / max_bin)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins inversely proportional to the sum of bin's current capacity and the item size to give precedence to bins with lower current capacities and minimize the usage of additional bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins + item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`The new algorithm calculates each bin's score by taking the difference between the bin's current capacity and the maximum capacity of the bin, multiplying it by the square root of the bin's load plus one, and dividing by the bin's capacity.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity - bin_capacity) * np.sqrt(bin_capacity + 1) / bin_capacity\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate each bin's score by subtracting the bin's current load from the maximum capacity of the bin and then multiplying by the reciprocal of its load.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity - bin_capacity) / (bin_capacity + 1) * np.exp(item / bin_capacity)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with smaller remaining capacities and larger capacities and uses a polynomial function to calculate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity >= 0] = 2 * (np.cos(np.pi * (remaining_capacity[remaining_capacity >= 0] / bins[remaining_capacity >= 0])) + 1)**2 + item / bins[remaining_capacity >= 0]\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate each bin's score by subtracting the bin's current load from a combination of the item size and maximum capacity of the bin and then multiplying by the reciprocal of its load plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity + item - bin_capacity) / (bin_capacity + 1)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by calculating the sum of their normalized capacity with the normalized size of the item and the square root of the bin index, while penalizing bins with less remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins >= item, (1 - bins / max_capacity) + (item / max_capacity) + np.sqrt(np.arange(len(bins))), -np.inf)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins for an item by scoring based on available bin space, prioritizing bins with a difference between maximum and mean bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins.mean()) - (bins - item))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate each bin's score by subtracting the bin's current load from the maximum capacity of the bin and then multiplying by the reciprocal of its load plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity - bin_capacity) / (bin_capacity + 1)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm should strive for diversity by assigning higher scores to bins that are closer to or further from the average bin capacity, effectively balancing utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mean_capacity = np.mean(bins)\\n scores = np.zeros_like(bins)\\n scores[bins < mean_capacity] = np.exp((bins[bins < mean_capacity] - item) / mean_capacity)\\n scores[bins >= mean_capacity] = np.exp((item - bins[bins >= mean_capacity]) / mean_capacity)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / bins.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Assign an item to a feasible bin with a high score calculated by the weighted sum of bin's height, remaining capacity, inverse index, and the ratio of current height to its maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 0.75 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) + 0.25 * (bins.size - np.arange(len(bins))) + np.log(normalized_remaining_capacities / (bins / bins.max()))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins)) / normalized_remaining_capacities.mean()\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The algorithm calculates the score of each bin as a combination of the remaining capacity, the negative of the bin's usage factor (i.e., the proportion of the bin that is already full), and the negative index of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() - 0.5 * bins / bins.max() - 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The method assigns an item to the bin with maximum score the calculated by the weighted sum of bin's current height and its index in the list, divided by bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * remaining_capacities / remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilize a weighted sum of bins' remaining capacity, but penalize bins with a large number of items and promote bins with a small number of items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() - bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Promote bins with a large number of items and penalize bins with a small number of items while considering the remaining capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_item_ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + bin_item_ratio / bin_item_ratio.max() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.75 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.75 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm gives priority to bins with smaller indices and a larger gap between their current height and maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 0.5 * remaining_capacities / remaining_capacities.min() + 0.3 * ((bins - item) / (bins - item).max()) ** 2 + 0.2 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, capacity, and its index in the list .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as a combination of its remaining capacity, the power of 0.6 of the ratio of its current height to the maximum height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (bins / bins.max()) ** 0.6 - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign an item to the feasible bin with the highest score calculated by the weighted sum of bin\\u2019s current height, remaining capacity, and its inverse index in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 2 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.5 * (bins / bins.max()) ** 2 + 0.5 * (bins.size - np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as a combination of the bin's normalized remaining capacity, the square root of the bin's current height, and the negative index of the bin in the list, where a higher index indicates a later position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * np.sqrt(bins / bins.max()) - 0.25 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score of each bin is a weighted sum of a high power of its remaining capacity to promote empty bins, a low power of its current height to penalize full bins, and its index in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 5) / remaining_capacities.min() - (bins / bins.max()) ** 0.2 + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores bins based on their capacity, considering the item's size, bin's original capacity, and the bin's position, with a logarithmic component and a weighted sum of these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * normalized_remaining_capacities / normalized_remaining_capacities.min() + 0.25 * (normalized_remaining_capacities / (bins / bins.max())) - 0.25 * np.arange(len(bins)) + np.log(bins / bins.max()) + np.array([(item / bins[i])**3 for i in range(0, len(bins))])\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 / bins ** 2 + remaining_capacities / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm determines the score of a bin based on the following criteria: the bin's remaining capacity, the bin's position, the bin's capacity, and the number of times the bin has been used. The score is calculated as the sum of these factors, each weighted by a different power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 3) / remaining_capacities.min() + (bins / bins.max()) ** 3 + np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as a weighted sum of the bin's current capacity to the power of 2, the difference between the bin's capacity and the item size, the number of items that fit into the bin, and the reciprocal of the standard deviation of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) + 1 / np.std(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a weighted sum of the bin's current size, its remaining capacity to the power of 3, the bin's capacity to the power of 2.5, the natural logarithm of the bin's remaining capacity, and the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = 1.5 * bins / bins.max() ** 2.5 + remaining_capacities ** 3 / remaining_capacities.min() + np.log(remaining_capacities) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the bin's remaining capacity to the power of 2, the bin's position in the list, the bin's capacity to the power of 3, and the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + (bins ** 3) / bins.max() ** 3 + remaining_capacities\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = bins - item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores using a combination of normalized capacity, item size, bin index, and a penalty for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_capacity = bins / max_capacity\\n normalized_item = item / max_capacity\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) / (bins - item + 1)\\n scores = normalized_capacity + normalized_item + np.sqrt(bin_index) + penalty\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = (normalized_remaining_capacities**2) / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score by penalizing bins with low remaining capacity and rewarding smaller bin indexes, while considering the ratio of the item size to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacity = bins / np.max(bins)\\n normalized_item = item / np.max(bins)\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) ** 2 / (bins - item + 1) ** 2\\n scores = normalized_capacity - normalized_item + 1 / np.sqrt(bin_index + 1) + penalty\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new score function assigns a higher score to bins with relatively larger rest capacity while considering the item size, encouraging diversity and avoiding early saturation of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = normalized_remaining_capacities / np.power(normalized_remaining_capacities, 1 + item / bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate each bin's score by multiplying the bin's current load by the reciprocal of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilizes a weighted sum of the normalized bin capacities, the number of items in each bin, and a penalty term for bins with less remaining capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacities = bins - item\\n num_items_in_bin = np.arange(len(bins)) + 1\\n penalty = 1 / (normalized_capacities + 1)\\n scores = 0.5 * normalized_capacities / max(bins) + 0.3 * penalty + 0.2 * num_items_in_bin\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of a bin by multiplying the bin's current load by the reciprocal of the difference between the bin's capacity and the item size, plus a random number that is drawn from a uniform distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) + np.random.uniform(0, 1, len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate each bin's score by multiplying the bin's current load by the reciprocal of the difference between the bin's capacity and the item size, plus the reciprocal of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 1 / (np.arange(len(bins))+1)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a bin's score as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size and the bin's previous total fill percentage, multiplied by the number of items assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins / bins.max()\\n scores = scores * (np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's previous total fill percentage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins / bins.max()\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign items to bins with scores based on the remaining capacity but also incorporate the item size, giving preference to bins that can accommodate the item without leaving too much empty space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_bin = np.max(bins)\\n available_space = bins - item\\n scores[available_space >= 0] = max_bin - (available_space[available_space >= 0] * item / max_bin)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins inversely proportional to the sum of bin's current capacity and the item size to give precedence to bins with lower current capacities and minimize the usage of additional bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins + item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`The new algorithm calculates each bin's score by taking the difference between the bin's current capacity and the maximum capacity of the bin, multiplying it by the square root of the bin's load plus one, and dividing by the bin's capacity.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity - bin_capacity) * np.sqrt(bin_capacity + 1) / bin_capacity\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate each bin's score by multiplying the bin's current load by the reciprocal of the bin's remaining capacity, exponentially penalized by a factor that discourages repeated use of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = bins / (bins - item + 1) * np.power(0.5, np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with smaller remaining capacities and larger capacities and uses a polynomial function to calculate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity >= 0] = 2 * (np.cos(np.pi * (remaining_capacity[remaining_capacity >= 0] / bins[remaining_capacity >= 0])) + 1)**2 + item / bins[remaining_capacity >= 0]\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates each bin's score by taking the difference between the bin's current capacity and the maximum capacity of the bin, multiplying it by the cubic root of the bin's load plus one, and dividing by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.full_like(bins, fill_value=0)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity != max_capacity:\\n scores[i] = (max_capacity - bin_capacity) * np.cbrt(bin_capacity + 1) / bin_capacity\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = bins - item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores using a combination of normalized capacity, item size, bin index, and a penalty for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_capacity = bins / max_capacity\\n normalized_item = item / max_capacity\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) / (bins - item + 1)\\n scores = normalized_capacity + normalized_item + np.sqrt(bin_index) + penalty\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is inspired by the idea of combining multiplication and addition operations to calculate the scores, but it introduces a unique formulation involving the reciprocal of a complex term and a weighted sum of bin properties.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = bins - item / bins\\n normalized_item_size = item / bins.max()\\n scores = bins / (bins - item) + (normalized_remaining_capacities * (1 - normalized_item_size)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the score of each bin utilizing the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, the current capacity, and the number of utilized bins, all divided by their respective maximum values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = normalized_remaining_capacities + reciprocal_remaining_capacities + bins / bins.max() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n distances_to_the_center = np.abs(bins - np.mean(bins)) / np.std(bins)\\n scores = (normalized_remaining_capacities**2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + (distances_to_the_center**2)\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = (normalized_remaining_capacities**2) / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign an item to the bin with the maximum score by penalizing bins with small ratio of rest capacity to maximum capacity, rewarding smaller bin indexes, and considering the quadratic ratio of the item size to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacity = bins / np.max(bins)\\n normalized_item = item / np.max(bins)\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) / (bins - item + 1)\\n scores = normalized_capacity - normalized_item**2 + 1 / np.sqrt(bin_index + 1) + penalty\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score by penalizing bins with low remaining capacity and rewarding smaller bin indexes, while considering the ratio of the item size to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacity = bins / np.max(bins)\\n normalized_item = item / np.max(bins)\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) ** 2 / (bins - item + 1) ** 2\\n scores = normalized_capacity - normalized_item + 1 / np.sqrt(bin_index + 1) + penalty\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new score function assigns a higher score to bins with relatively larger rest capacity while considering the item size, encouraging diversity and avoiding early saturation of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = normalized_remaining_capacities / np.power(normalized_remaining_capacities, 1 + item / bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate each bin's score by multiplying the bin's current load by the reciprocal of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilizes a weighted sum of the normalized bin capacities, the number of items in each bin, and a penalty term for bins with less remaining capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacities = bins - item\\n num_items_in_bin = np.arange(len(bins)) + 1\\n penalty = 1 / (normalized_capacities + 1)\\n scores = 0.5 * normalized_capacities / max(bins) + 0.3 * penalty + 0.2 * num_items_in_bin\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified algorithm using a weighted sum of normalized bin capacities, the reciprocal of remaining capacity, and a preference for bins with fewer items assigned\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacities = bins - item\\n reciprocal_remaining_capacity = bins / (bins - item)\\n num_items_in_bin = np.arange(len(bins)) + 1\\n scores = 0.5 * normalized_capacities / max(bins) + 0.3 * reciprocal_remaining_capacity + 0.2 * num_items_in_bin\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of a bin by multiplying the bin's current load by the reciprocal of the difference between the bin's capacity and the item size, plus a random number that is drawn from a uniform distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) + np.random.uniform(0, 1, len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate each bin's score by multiplying the bin's current load by the reciprocal of the difference between the bin's capacity and the item size, plus the reciprocal of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 1 / (np.arange(len(bins))+1)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjust weights of the existing score function to prioritize bins with fewer items and larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacities = bins - item\\n reciprocal_remaining_capacity = bins / (bins - item)\\n num_items_in_bin = np.arange(len(bins)) + 1\\n scores = 0.6 * normalized_capacities / max(bins) + 0.3 * reciprocal_remaining_capacity - 0.1 * num_items_in_bin\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a bin's score as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size and the bin's previous total fill percentage, multiplied by the number of items assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins / bins.max()\\n scores = scores * (np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the bin's previous total fill percentage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + bins / bins.max()\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = bins - item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm computes the score by multiplying a weight vector with the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, the square root of the remaining capacity, and the number of utilized bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1, 1, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + weight_vector[3] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores using a combination of normalized capacity, item size, bin index, and a penalty for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_capacity = bins / max_capacity\\n normalized_item = item / max_capacity\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) / (bins - item + 1)\\n scores = normalized_capacity + normalized_item + np.sqrt(bin_index) + penalty\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is inspired by the idea of combining multiplication and addition operations to calculate the scores, but it introduces a unique formulation involving the reciprocal of a complex term and a weighted sum of bin properties.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = bins - item / bins\\n normalized_item_size = item / bins.max()\\n scores = bins / (bins - item) + (normalized_remaining_capacities * (1 - normalized_item_size)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score by multiplying a weight vector with the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, and the number of utilized bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the score of each bin utilizing the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, the current capacity, and the number of utilized bins, all divided by their respective maximum values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = normalized_remaining_capacities + reciprocal_remaining_capacities + bins / bins.max() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score by multiplying the exponential of the normalized remaining capacity with the reciprocal of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n distances_to_the_center = np.abs(bins - np.mean(bins)) / np.std(bins)\\n scores = np.exp(normalized_remaining_capacities) / (bins - item) + np.arange(len(bins)) + (distances_to_the_center**2)\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = (normalized_remaining_capacities**2) / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n distances_to_the_center = np.abs(bins - np.mean(bins)) / np.std(bins)\\n scores = (normalized_remaining_capacities) / normalized_remaining_capacities.min() + np.arange(len(bins)) + (distances_to_the_center)\\n return scores\",\n \"objective\": 0.02395,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm using the cube of the normalized remaining capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = (normalized_remaining_capacities**3) / normalized_remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of the normalized remaining capacity, the reciprocal of the remaining capacity, and the bin's position, modulated by the bin's usage count.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 0.5, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n bin_usage_count = (bins == 0).astype(int)\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * np.arange(len(bins)) * (1 - bin_usage_count)\\n return scores\",\n \"objective\": 0.02566,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns an item to the bin with the maximum score, with priority and penalty for used bins, and updates the bin's capacity and usage count accordingly.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / bins\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins)) * (bins != item) - (bins == item) * 100\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n distances_to_the_center = np.abs(bins - np.mean(bins)) / np.std(bins)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.02626,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score calculated by adding the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's distance to the center of bins, and the bin's number of assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n distances_to_the_center = np.abs(bins - np.mean(bins)) / np.std(bins)\\n scores = (normalized_remaining_capacities**2) / normalized_remaining_capacities.min() + np.sqrt(distances_to_the_center) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm finds the score by calculating the product of the remaining capacity and the reciprocal of the difference between the bin's capacity and the item size, added with a weight vector multiplied by the square root of the difference and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n weight_vector = np.array([1, 2, 3])\\n scores = remaining_capacities * (1 / (bins - item)) + weight_vector[0] * np.sqrt(bins - item) + weight_vector[1] * np.sqrt(bins - item) + weight_vector[2] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign an item to the bin with the maximum score by penalizing bins with small ratio of rest capacity to maximum capacity, rewarding smaller bin indexes, and considering the quadratic ratio of the item size to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacity = bins / np.max(bins)\\n normalized_item = item / np.max(bins)\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) / (bins - item + 1)\\n scores = normalized_capacity - normalized_item**2 + 1 / np.sqrt(bin_index + 1) + penalty\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score by penalizing bins with low remaining capacity and rewarding smaller bin indexes, while considering the ratio of the item size to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_capacity = bins / np.max(bins)\\n normalized_item = item / np.max(bins)\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) ** 2 / (bins - item + 1) ** 2\\n scores = normalized_capacity - normalized_item + 1 / np.sqrt(bin_index + 1) + penalty\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin's score is a combination of the bin's capacity, the bin's current load, and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_bin_load = bins / bins.max()\\n normalized_remaining_capacities = (bins - item) / item\\n scores = bins * normalized_bin_load / (bins - item) + (1 - normalized_bin_load) * normalized_remaining_capacities\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new score function assigns a higher score to bins with relatively larger rest capacity while considering the item size, encouraging diversity and avoiding early saturation of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n scores = normalized_remaining_capacities / np.power(normalized_remaining_capacities, 1 + item / bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as a weighted sum of the reciprocal of the remaining capacity, the bin's position, and the bin's usage count, modulated by the sum of the capacities of the bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([1, 0.2, 0.3])\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n bin_usage_count = (bins == 0).astype(int)\\n normalized_capacities = (bins + 0.001) / (bins + 0.001).max()\\n scores = weight_vector[0] * reciprocal_remaining_capacities + weight_vector[1] * np.arange(len(bins)) * (1 - bin_usage_count) + weight_vector[2] * np.sum(normalized_capacities)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of the weighted score of normalized remaining capacity, the reciprocal of the remaining capacity, and the square root of the remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([4, 2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = remaining_capacities / remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the product of the normalized remaining capacity and the reciprocal of the remaining capacity with the sum of weight vector and the indices of bins to calculate scores. The product puts more emphasis on bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([1, 2])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = np.multiply(normalized_remaining_capacities, reciprocal_remaining_capacities) * np.sum(weight_vector) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin based on item size, bin capacity, the ratio of bin capacity to item size, and the remaining capacity of bins, whereas the new algorithm takes the logarithm of bin capacity and the remaining capacity of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n ratio = bins / item\\n scores = normalized_remaining_capacities + reciprocal_remaining_capacities + ratio + bins / bins.max() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Multiplies a weight vector with the product of the normalized product of the rest capacity divided by the average capacity and the reciprocal of the rest capacity to calculate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).mean()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).mean() * np.log2(bins - item)\\n scores = weight_vector[0] * normalized_remaining_capacities * reciprocal_remaining_capacities + weight_vector[1] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies a weight vector with the product of the normalized remaining capacity and the reciprocal of the remaining capacity to calculate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = weight_vector[0] * normalized_remaining_capacities * reciprocal_remaining_capacities + weight_vector[1] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm computes the score by multiplying a weight vector with the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, the square root of the remaining capacity, and the number of utilized bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1, 1, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + weight_vector[3] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores using a combination of normalized capacity, item size, bin index, and a penalty for bins with low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_capacity = bins / max_capacity\\n normalized_item = item / max_capacity\\n bin_index = np.arange(len(bins))\\n penalty = 1 - (bins - item) / (bins - item + 1)\\n scores = normalized_capacity + normalized_item + np.sqrt(bin_index) + penalty\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is inspired by the idea of combining multiplication and addition operations to calculate the scores, but it introduces a unique formulation involving the reciprocal of a complex term and a weighted sum of bin properties.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = bins - item / bins\\n normalized_item_size = item / bins.max()\\n scores = bins / (bins - item) + (normalized_remaining_capacities * (1 - normalized_item_size)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score by multiplying a weight vector with the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, and the number of utilized bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores using a combination of normalized capacity, item size, bin index, exponential of rest capacity, and inverse of bin order. The exponent is greater than one to intensify the impact of small rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_capacity = bins / max_capacity\\n normalized_item = item / max_capacity\\n bin_index = np.arange(len(bins))\\n penalty = np.exp(1 - (bins - item) / (bins - item + 1))\\n order = 1 / (bin_index + 1)\\n scores = normalized_capacity + normalized_item + np.sqrt(bin_index) + penalty + order\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New normalized algorithm: Weighted sum of the normalized remaining capacity, the reciprocal of the remaining capacity, the bin's position, and the bin's usage count, modulated by the sum of the normalized capacities of the bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([1, 0.1, 0.2, 0.3])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n bin_usage_count = (bins == 0).astype(int)\\n normalized_capacities = (bins) / (bins).max()\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * np.arange(len(bins)) * (1 - bin_usage_count) + weight_vector[3] * np.sum(1 - normalized_capacities)\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the score of each bin utilizing the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, the current capacity, and the number of utilized bins, all divided by their respective maximum values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = normalized_remaining_capacities + reciprocal_remaining_capacities + bins / bins.max() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score by multiplying the exponential of the normalized remaining capacity with the reciprocal of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n distances_to_the_center = np.abs(bins - np.mean(bins)) / np.std(bins)\\n scores = np.exp(normalized_remaining_capacities) / (bins - item) + np.arange(len(bins)) + (distances_to_the_center**2)\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel score function that calculates scores based on the ratio of bin capacity to item size, considering the number of times a bin has been used and the ratio of the remaining capacity to the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = (normalized_remaining_capacities**2) / normalized_remaining_capacities.min() + (normalized_capacities**2) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as a weighted sum of the reciprocal of the remaining capacity, the bin's position, and the bin's usage count, modulated by the sum of the capacities of the bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([1, 0.2, 0.3])\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n bin_usage_count = (bins == 0).astype(int)\\n normalized_capacities = (bins + 0.001) / (bins + 0.001).max()\\n scores = weight_vector[0] * reciprocal_remaining_capacities + weight_vector[1] * np.arange(len(bins)) * (1 - bin_usage_count) + weight_vector[2] * np.sum(normalized_capacities)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, and the score from the previous step.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) // 2 + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of the weighted score of normalized remaining capacity, the reciprocal of the remaining capacity, and the square root of the remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([4, 2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, the square root of the bin's capacity, and the reciprocal of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) // 2 + np.arange(len(bins)) + np.sqrt(bins) + 1 / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a current item to the bin with the maximum score and updates the rest capacity of the bins, until all items are assigned. The score is calculated based on the bin's rest capacity, the difference between the bin's rest capacity and the item size, the number of times the bin has been used, and the square of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n used_bins_scores = np.arange(len(bins))\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + used_bins_scores + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigning the item to the bin with the maximum score defined as a weighted sum of the bin's rest capacity, the ratio of the bin's rest capacity to the item size, the bin's index, the bin's capacity divided by the item size, the ratio of the number of items that can fit into the bin to the number of items that can fit in the best bin, and the square of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n num_fits = bins / item / np.max(bins / item)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins)) + normalized_capacities / normalized_capacities.min() + num_fits + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = remaining_capacities / remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as the square root of the sum of the weighted square of the bin's current capacity and the exponential of the ratio of the bin's capacity to the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weighted_capacities = np.sqrt(((bins - item) ** 2) / (bins - item).min())\\n ratios = bins / item\\n scores = weighted_capacities + np.exp(ratios) + np.arange(len(bins)) + np.sqrt(np.abs(bins - np.mean(bins)) / np.std(bins))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the product of the normalized remaining capacity and the reciprocal of the remaining capacity with the sum of weight vector and the indices of bins to calculate scores. The product puts more emphasis on bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([1, 2])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = np.multiply(normalized_remaining_capacities, reciprocal_remaining_capacities) * np.sum(weight_vector) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are computed by combining a bin's normalized remaining capacity, reciprocal of remaining capacity, square of normalized remaining capacity, ratio of bin capacity to item size, and the number of bins utilized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n sqr_normalized_remaining_capacities = np.square(normalized_remaining_capacities)\\n ratio = bins / item\\n scores = normalized_remaining_capacities + reciprocal_remaining_capacities + sqr_normalized_remaining_capacities + ratio + bins / bins.max() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted score of the product of volume reduction and reciprocal remaining capacity, and the product of volume reduction and square root of remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([3, 2, 1])\\n volume_reductions = bins - item\\n normalized_volume_reductions = volume_reductions / volume_reductions.max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_volume_reductions * reciprocal_remaining_capacities + weight_vector[1] * normalized_volume_reductions * sqrt_remaining_capacities + weight_vector[2] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Amodified algorithmis to compute the score by multiplying a weight vector with the sum of the normalized remaining capacity, the reciprocal of the remaining capacity, the square root of the remaining capacity, the square of the remaining capacity, and the number of utilized bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1, 1, 1, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n sqr_remaining_capacities = np.square((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + weight_vector[3] * sqr_remaining_capacities + weight_vector[4] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity plus score of the previous step, and the ratio of bin capacity to item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n ratio = bins / item\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + ratio\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin based on item size, bin capacity, the ratio of bin capacity to item size, and the remaining capacity of bins, whereas the new algorithm takes the logarithm of bin capacity and the remaining capacity of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n ratio = bins / item\\n scores = normalized_remaining_capacities + reciprocal_remaining_capacities + ratio + bins / bins.max() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Multiplies a weight vector with the product of the normalized product of the rest capacity divided by the average capacity and the reciprocal of the rest capacity to calculate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).mean()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).mean() * np.log2(bins - item)\\n scores = weight_vector[0] * normalized_remaining_capacities * reciprocal_remaining_capacities + weight_vector[1] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the difference between the bin's capacity and item size in a quadratic form, the reciprocal of the bin's current capacity, the reciprocal of bin's volume, and the difference between bin's capacity and the item size to the power of 1.25 multiplied by the square root of the distance to the center.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_volumes = bins * normalized_remaining_capacities\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) + (1 / bin_volumes) + (1 / np.sqrt(bin_volumes)) + ((bins - item) ** 1.25) * np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as a product of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the sum of the squared differences between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n normalized_capacities = bins / item\\n used_bins_scores = np.arange(len(bins))\\n difference = np.abs(bins - item)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + used_bins_scores + np.sum(difference**2) / np.sum(difference**2).max()\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the highest score, calculated as a cubed sum of a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the distance to the center of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) + np.abs(bins - np.mean(bins))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the cube of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the square root of the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = np.sqrt(bins / item / np.max(bins / item))\\n scores = (normalized_remaining_capacities ** 3) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, and the score from the previous step.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) // 2 + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of the weighted score of normalized remaining capacity, the reciprocal of the remaining capacity, and the square root of the remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([4, 2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, the square root of the bin's capacity, and the reciprocal of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) // 2 + np.arange(len(bins)) + np.sqrt(bins) + 1 / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score defined as a weighted sum of the bin's rest capacity to the power of 3, the ratio of the bin's rest capacity to the item size, the bin's index, the bin's capacity divided by the item size, the ratio of the number of items that can fit into the bin to the number of items that can fit in the best bin, and the ratio of the square of the bin's current capacity to the square of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n num_fits = bins / item / np.max(bins / item)\\n scores = (bins**3) / (bins**3).max() + normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins)) + normalized_capacities / normalized_capacities.min() + num_fits + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a current item to the bin with the maximum score and updates the rest capacity of the bins, until all items are assigned. The score is calculated based on the bin's rest capacity, the difference between the bin's rest capacity and the item size, the number of times the bin has been used, and the square of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n used_bins_scores = np.arange(len(bins))\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + used_bins_scores + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigning the item to the bin with the maximum score defined as a weighted sum of the bin's rest capacity, the ratio of the bin's rest capacity to the item size, the bin's index, the bin's capacity divided by the item size, the ratio of the number of items that can fit into the bin to the number of items that can fit in the best bin, and the square of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n num_fits = bins / item / np.max(bins / item)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins)) + normalized_capacities / normalized_capacities.min() + num_fits + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted score of the product of volume reduction and reciprocal remaining capacity, and the product of volume reduction and square root of remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([3, 2, 1])\\n volume_reductions = bins - item\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n scores = weight_vector[0] * volume_reductions / volume_reductions.max() * reciprocal_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score calculated as the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = remaining_capacities / remaining_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as the square root of the sum of the weighted square of the bin's current capacity and the exponential of the ratio of the bin's capacity to the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weighted_capacities = np.sqrt(((bins - item) ** 2) / (bins - item).min())\\n ratios = bins / item\\n scores = weighted_capacities + np.exp(ratios) + np.arange(len(bins)) + np.sqrt(np.abs(bins - np.mean(bins)) / np.std(bins))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: prioritize distance to the center by increasing the weight and applying a square operation and using the fourth power of the size difference\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_volumes = bins * normalized_remaining_capacities\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) + (1 / bin_volumes) + (1 / np.sqrt(bin_volumes)) + ((bins - item) ** 4) * (distances_to_the_center ** 2)\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiplies the product of the normalized remaining capacity and the reciprocal of the remaining capacity with the sum of weight vector and the indices of bins to calculate scores. The product puts more emphasis on bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([1, 2])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log2(bins - item)\\n scores = np.multiply(normalized_remaining_capacities, reciprocal_remaining_capacities) * np.sum(weight_vector) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/Gemini/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the difference between the bin's capacity and item size in a quadratic form, the reciprocal of the bin's current capacity, the reciprocal of bin's volume, and the difference between bin's capacity and the item size to the power of 1.25 multiplied by the square root of the distance to the center.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n bin_volumes = bins * normalized_remaining_capacities\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) + (1 / bin_volumes) + (1 / np.sqrt(bin_volumes)) + ((bins - item) ** 1.25) * np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a weighted sum of the square of bin capacity, bin index, a random number, distance to the center, and number of items fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.random.uniform(0, 1, len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as the square root of the sum of the weighted square of the bin's current capacity and the arctangent of the ratio of the bin's capacity to the item size, plus the number of times the bin has been used, plus the square of the bin's distance to the center of bins.\",\n \"code\": \"import numpy as np\\nfrom math import atan, sqrt\\n\\ndef score(item, bins):\\n weighted_capacities = np.sqrt(((bins - item) ** 2) / (bins - item).min())\\n ratios = bins / item\\n scores = weighted_capacities + np.arctan(ratios) + np.arange(len(bins)) + np.sqrt(np.abs(bins - np.mean(bins)) / np.std(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n distances_to_the_center = np.minimum(np.abs(bins - np.mean(bins)) / np.std(bins), 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + np.sqrt(distances_to_the_center) + num_fits\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities ** 2) / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the highest score, calculated as a cubed sum of a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the distance to the center of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) + np.abs(bins - np.mean(bins))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted combination of the bin's remaining capacity that is penalized by the number of item that can be fit into the bin and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n num_fits = bins / item / np.max(bins / item)\\n scores = (normalized_remaining_capacities - (normalized_remaining_capacities / np.sum(normalized_remaining_capacities)) * num_fits)**2 / normalized_remaining_capacities.min() + np.arange(len(bins)) + num_fits\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, and the number of items that fit into the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, and the score from the previous step.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) + np.arange(len(bins)) // 2 + np.arange(len(bins)) + 1\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of the weighted score of normalized remaining capacity, the reciprocal of the remaining capacity, and the square root of the remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([4, 2, 1])\\n normalized_remaining_capacities = (bins - item) / (bins - item).max()\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n sqrt_remaining_capacities = np.sqrt((bins - item) / (bins - item).max())\\n scores = weight_vector[0] * normalized_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * sqrt_remaining_capacities + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted sum of the square of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, the distance to the center of bins, the number of items that fit into the bin, the square root of the bin's capacity, and the reciprocal of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = np.minimum((bins - item) / item, 1)\\n scores = (remaining_capacities ** 2) / remaining_capacities.min() + (bins - item) / item + np.arange(len(bins)) // 2 + np.arange(len(bins)) + np.sqrt(bins) + 1 / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score defined as a weighted sum of the bin's rest capacity to the power of 3, the ratio of the bin's rest capacity to the item size, the bin's index, the bin's capacity divided by the item size, the ratio of the number of items that can fit into the bin to the number of items that can fit in the best bin, and the ratio of the square of the bin's current capacity to the square of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n num_fits = bins / item / np.max(bins / item)\\n scores = (bins**3) / (bins**3).max() + normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins)) + normalized_capacities / normalized_capacities.min() + num_fits + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a current item to the bin with the maximum score and updates the rest capacity of the bins, until all items are assigned. The score is calculated based on the bin's rest capacity, the difference between the bin's rest capacity and the item size, the number of times the bin has been used, and the square of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n used_bins_scores = np.arange(len(bins))\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + used_bins_scores + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified weighted score of the product of inverse volume reduction and remaining capacity, and the product of volume reduction and square root of remaining capacity, and the number of used bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([3, 2, 1])\\n volume_reductions = bins - item\\n remaining_capacities = bins - item\\n scores = weight_vector[0] * 1.0 / volume_reductions * remaining_capacities + weight_vector[1] * remaining_capacities / remaining_capacities.max() * np.sqrt(remaining_capacities) + weight_vector[2] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigning the item to the bin with the maximum score defined as a weighted sum of the bin's rest capacity, the ratio of the bin's rest capacity to the item size, the bin's index, the bin's capacity divided by the item size, the ratio of the number of items that can fit into the bin to the number of items that can fit in the best bin, and the square of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n num_fits = bins / item / np.max(bins / item)\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + np.arange(len(bins)) + normalized_capacities / normalized_capacities.min() + num_fits + (bins**2) / (bins**2).max()\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted score of the product of volume reduction and reciprocal remaining capacity, and the product of volume reduction and square root of remaining capacity, and the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_vector = np.array([3, 2, 1])\\n volume_reductions = bins - item\\n reciprocal_remaining_capacities = (bins - item) / (bins - item).max() * np.log(bins - item)\\n scores = weight_vector[0] * volume_reductions / volume_reductions.max() * reciprocal_remaining_capacities + weight_vector[1] * reciprocal_remaining_capacities + weight_vector[2] * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score calculated as a weighted combination of the bin's remaining capacity that is penalized by the average load factor of all feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = np.minimum((bins - item) / item, 1)\\n avg_load = bins.mean() / bins\\n scores = (normalized_remaining_capacities - (normalized_remaining_capacities / np.sum(normalized_remaining_capacities)) * avg_load)**2 / normalized_remaining_capacities.min() + avg_load + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as a weighted sum of the bin's current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score calculated based on the weighted sum of the bin's rest capacity, the difference between the bin's rest capacity and the item size, the number of times the bin has been used, the bin's capacity, and the reciprocal of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_remaining_capacities = (bins - item) / item\\n normalized_capacities = bins / item\\n used_bins_scores = np.arange(len(bins))\\n reciprocal_capacities = 1 / bins\\n scores = normalized_remaining_capacities / normalized_remaining_capacities.min() + normalized_capacities / normalized_capacities.min() + used_bins_scores + bins / bins.max() + reciprocal_capacities / reciprocal_capacities.max()\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The score of each bin is calculated as the product of the inverse of its rest capacity and a weight that is inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the weight for each bin based on its index\\n weight = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * weight\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the ratio of the item size to the bin's rest capacity, considering the condition of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the ratio of the item size to the bin's rest capacity\\n scores = np.divide(item, bins)\\n \\n # Consider the condition of the rest capacity\\n scores[np.where(bins == 0)] = 0\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new scoring function will calculate the score for each bin by multiplying the rest capacity with the inverse of the bin's index to prioritize bins with more rest capacity and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.multiply(bins, 1 / (np.arange(len(bins)) + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Modify the score by adding the inverse of the bin's index to the product of the rest capacity and the inverse of its index to promote bins with higher rest capacities and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's index\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the product of the rest capacity and the inverse of its index\\n prod = bins * inv_index\\n \\n # Add the inverse of the bin's index to the product\\n scores = prod + inv_index\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will be calculated based on the rest capacity of bins by penalizing bins with less remaining capacity and prioritizing bins closer to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacity\\n diff = np.abs(item - bins)\\n \\n # Penalize bins with less remaining capacity\\n penalty = np.maximum(0, (diff / bins))\\n \\n # Prioritize bins closer to the item size\\n priority = np.exp(-np.square(diff))\\n \\n # Combine the penalty and priority scores\\n scores = penalty * priority\\n \\n return scores\",\n \"objective\": 0.04749,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the rest capacity, using a weighted average of the inverse of the bin number and the square of the rest capacity, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the rest capacity\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (1 / (bin - item + 1)) * (bin ** 2)\\n return scores\",\n \"objective\": 0.05353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with less remaining capacity and penalizes bins closer to the item size, using an exponential decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the penalty for each bin based on its distance from the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Calculate the priority of each bin based on its remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Combine the penalty and priority to get the final score for each bin\\n scores = penalty * priority\\n \\n return scores\",\n \"objective\": 0.05514,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the total score for each bin by considering the relative remaining capacity and subtracting a penalty proportional to the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the relative remaining capacity for each bin\\n rel_remaining = (bins - item) / bins\\n \\n # Subtract a penalty proportional to the bin's index\\n penalty = np.arange(len(bins)) * 0.1\\n \\n # Calculate the total score for each bin\\n scores = rel_remaining - penalty\\n \\n return scores\",\n \"objective\": 0.06198,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm multiplies the rest capacity of each bin to a power representing the bin's index, then divides the result by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.power(bins, item) / item\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.06942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will score each bin based on its normalized remaining capacity and a weighted inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized remaining capacity for each bin\\n norm_remaining = (bins - item) / bins\\n \\n # Calculate the weighted inverse of the index for each bin\\n weighted_inverse = 1 / (np.arange(len(bins)) + 1)\\n \\n # Combine the two scores using element-wise multiplication\\n scores = norm_remaining * weighted_inverse\\n \\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score as the product of the inverse of the rest capacity and a term that is exponentially proportional to the bin's index and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * item)\\n \\n # Calculate the score\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin proportional to the reciprocal of its rest capacity, multiplied by a term that decays rapidly with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity for each bin\\n reciprocal_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the decay term for each bin\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the inverse of its rest capacity and the inverse of the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the inverse of the sum of the index and the item size\\n inv_sum = 1 / (np.arange(len(bins)) + item)\\n \\n # Multiply the two inverse quantities to get the score for each bin\\n scores = inv_rest_capacity * inv_sum\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the square of the inverse of its rest capacity divided by the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.square(np.divide(1, bins)) / (np.sum(bins) + item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is calculated as the product of the bin's index weighted by the inverse of its rest capacity and an exponentially increasing term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponentially increasing term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score as the product of the inverse of the rest capacity and a term that is exponentially proportional to the bin's index and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * item)\\n \\n # Calculate the score\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin proportional to the reciprocal of its rest capacity, multiplied by a term that decays rapidly with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity for each bin\\n reciprocal_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the decay term for each bin\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score for each bin based on the exponential decay function of its index and a weight inversely proportional to its rest capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its index and a weight inversely proportional to its rest capacity\\n scores = np.exp(-np.arange(len(bins)) / (item + 1)) * (1 - bins / (item + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score as the product of the inverse of the rest capacity and a term that is exponentially proportional to the bin's index and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * item)\\n \\n # Calculate the score\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is calculated by multiplying the inverse of the bin's rest capacity by an exponentially decaying function of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponentially decaying function of the bin's index\\n exp_decay = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the two arrays element-wise\\n scores = inv_rest_capacity * exp_decay\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score for each bin based on the exponential decay function of its index and a weight inversely proportional to its rest capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its index and a weight inversely proportional to its rest capacity\\n scores = np.exp(-np.arange(len(bins)) / (item + 1)) * (1 - bins / (item + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score as the product of the inverse of the rest capacity and a term that is exponentially proportional to the bin's index and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * item)\\n \\n # Calculate the score\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is calculated by multiplying the inverse of the bin's rest capacity by an exponentially decaying function of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponentially decaying function of the bin's index\\n exp_decay = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the two arrays element-wise\\n scores = inv_rest_capacity * exp_decay\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index cubed\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 3)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score for each bin based on the exponential decay function of its index and a weight inversely proportional to its rest capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its index and a weight inversely proportional to its rest capacity\\n scores = np.exp(-np.arange(len(bins)) / (item + 1)) * (1 - bins / (item + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score as the product of the inverse of the rest capacity and a term that is exponentially proportional to the bin's index and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * item)\\n \\n # Calculate the score\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is calculated by multiplying the inverse of the bin's rest capacity by an exponentially decaying function of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponentially decaying function of the bin's index\\n exp_decay = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the two arrays element-wise\\n scores = inv_rest_capacity * exp_decay\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with more remaining capacity and penalize bins closer to the item size using a Gaussian distribution function for the priority and a linear decay function for the penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the prioritization factor based on the remaining capacity\\n prioritization_factor = np.exp(-(bins - item)**2 / (2 * (item + 1)**2))\\n \\n # Calculate the penalty factor based on the distance from the item size\\n penalty_factor = np.abs(bins - item) / (item + 1)\\n \\n # Combine the prioritization and penalty factors to get the final score\\n scores = prioritization_factor * (1 - penalty_factor)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index cubed.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index cubed\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 3)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is directly proportional to the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, with an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover_space = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_remaining_capacity * linear_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score as the product of the inverse of the rest capacity and a term that is exponentially proportional to the bin's index and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * item)\\n \\n # Calculate the score\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is directly proportional to the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover_space = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_remaining_capacity * exp_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is calculated by multiplying the inverse of the bin's rest capacity by an exponentially decaying function of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponentially decaying function of the bin's index\\n exp_decay = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the two arrays element-wise\\n scores = inv_rest_capacity * exp_decay\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Compute the score of each bin as a combination of a bin preference factor, which is inversely proportional to the square root of the bin's index, and a bin capacity factor, which is computed as the square root of the inverse of the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the preference factor for each bin\\n pref_factor = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n \\n # Calculate the capacity factor for each bin\\n cap_factor = np.sqrt(1 / (bins - item))\\n \\n # Combine the preference and capacity factors to get the overall score\\n scores = pref_factor * cap_factor\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with more remaining capacity and penalize bins closer to the item size using a Gaussian distribution function for the priority and a linear decay function for the penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the prioritization factor based on the remaining capacity\\n prioritization_factor = np.exp(-(bins - item)**2 / (2 * (item + 1)**2))\\n \\n # Calculate the penalty factor based on the distance from the item size\\n penalty_factor = np.abs(bins - item) / (item + 1)\\n \\n # Combine the prioritization and penalty factors to get the final score\\n scores = prioritization_factor * (1 - penalty_factor)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score as the product of the inverse of the rest capacity and a term that is exponentially proportional to the bin's index and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * item)\\n \\n # Calculate the score\\n scores = inv_rest_capacity * exp_term\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases exponentially with increasing bin index, and an additional term that is proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the potential leftover space\\n potential_leftover_space = bins - item\\n \\n # Calculate the score for each bin\\n scores = log_remaining_capacity * exp_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is calculated by multiplying the inverse of the bin's rest capacity by an exponentially decaying function of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponentially decaying function of the bin's index\\n exp_decay = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the two arrays element-wise\\n scores = inv_rest_capacity * exp_decay\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Compute the score of each bin as a combination of a bin preference factor, which is inversely proportional to the square root of the bin's index, and a bin capacity factor, which is computed as the square root of the inverse of the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the preference factor for each bin\\n pref_factor = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n \\n # Calculate the capacity factor for each bin\\n cap_factor = np.sqrt(1 / (bins - item))\\n \\n # Combine the preference and capacity factors to get the overall score\\n scores = pref_factor * cap_factor\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins))) * 3\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases exponentially with increasing bin index, and an additional term that is proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the potential leftover space\\n potential_leftover_space = bins - item\\n \\n # Calculate the score for each bin\\n scores = log_remaining_capacity * exp_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the bin's index and the inverse of the item's size\\n prod_index_inv_size = np.arange(len(bins)) * (1 / item)\\n \\n # Sum the inverse of the bin's rest capacity and the product of the bin's index and the inverse of the item's size\\n scores = inv_rest_capacity + prod_index_inv_size\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is calculated by multiplying the inverse of the bin's rest capacity by an exponentially decaying function of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponentially decaying function of the bin's index\\n exp_decay = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the two arrays element-wise\\n scores = inv_rest_capacity * exp_decay\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins))) * 3\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases exponentially with increasing bin index, and an additional term that is proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the potential leftover space\\n potential_leftover_space = bins - item\\n \\n # Calculate the score for each bin\\n scores = log_remaining_capacity * exp_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins))) * 3\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases exponentially with increasing bin index, and an additional term that is proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the potential leftover space\\n potential_leftover_space = bins - item\\n \\n # Calculate the score for each bin\\n scores = log_remaining_capacity * exp_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The novel score function is a product of the inverse of the ratio between the rest capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the rest capacity of a bin and the item size\\n inv_ratios = 1 / (bins - item)\\n \\n # Calculate the exponential weight based on the bin index\\n weights = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the inverse ratios and weights to get the final scores\\n scores = inv_ratios * weights\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score of each bin is calculated as the product of the inverse of its rest capacity and a weight that is inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the weight for each bin based on its index\\n weight = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * weight\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score based on the exponential of the difference between the item size and bin capacity, multiplied by the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is calculated as the product of the bin\\u2019s rest capacity and exponential decay function of the bin\\u2019s index, divided by the distance between the item size and the bin\\u2019s size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the exponential decay function of the bin's index\\n decay_function = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Calculate the score for each bin\\n scores = rest_capacity * decay_function / (item - bins)\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the bin scores by multiplying the rest capacity by the squared inverse of the bin's index, and then dividing by the sum of the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = np.multiply(bins, 1 / (np.square(np.arange(len(bins)) + 1)))\\n \\n # Normalize the scores\\n scores = scores / np.sum(scores)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new scoring function will calculate the score for each bin by multiplying the rest capacity with the inverse of the bin's index to prioritize bins with more rest capacity and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.multiply(bins, 1 / (np.arange(len(bins)) + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Modify the score by adding the inverse of the bin's index to the product of the rest capacity and the inverse of its index to promote bins with higher rest capacities and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's index\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the product of the rest capacity and the inverse of its index\\n prod = bins * inv_index\\n \\n # Add the inverse of the bin's index to the product\\n scores = prod + inv_index\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins farther from the item size using a Gaussian distribution function for the priority and a linear decay function for the penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the prioritization factor based on the remaining capacity of the bins\\n prioritization_factor = np.exp(-np.square(bins - item) / (2 * np.square(item)))\\n \\n # Calculate the penalty factor based on the distance between the item size and the bin sizes\\n penalty_factor = np.abs(bins - item)\\n \\n # Combine the prioritization and penalty factors to get the final score\\n scores = prioritization_factor * (1 - penalty_factor)\\n \\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will be calculated based on the rest capacity of bins by penalizing bins with less remaining capacity and prioritizing bins closer to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacity\\n diff = np.abs(item - bins)\\n \\n # Penalize bins with less remaining capacity\\n penalty = np.maximum(0, (diff / bins))\\n \\n # Prioritize bins closer to the item size\\n priority = np.exp(-np.square(diff))\\n \\n # Combine the penalty and priority scores\\n scores = penalty * priority\\n \\n return scores\",\n \"objective\": 0.04749,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the rest capacity, using a weighted average of the inverse of the bin number and the square of the rest capacity, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the rest capacity\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (1 / (bin - item + 1)) * (bin ** 2)\\n return scores\",\n \"objective\": 0.05353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm prioritizes bins with less remaining capacity and penalizes bins closer to the item size, using an exponential decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the penalty for each bin based on its distance from the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Calculate the priority of each bin based on its remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Combine the penalty and priority to get the final score for each bin\\n scores = penalty * priority\\n \\n return scores\",\n \"objective\": 0.05514,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is inversely proportional to the potential leftover space. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * linear_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins))) * 3\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases exponentially with increasing bin index, and an additional term that is proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the potential leftover space\\n potential_leftover_space = bins - item\\n \\n # Calculate the score for each bin\\n scores = log_remaining_capacity * exp_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is inversely proportional to the potential leftover space. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * linear_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins))) * 3\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases exponentially with increasing bin index, and an additional term that is proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_remaining_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the potential leftover space\\n potential_leftover_space = bins - item\\n \\n # Calculate the score for each bin\\n scores = log_remaining_capacity * exp_term + potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, raised to the power of a parameter exponent, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_capacity = 1 / bins\\n \\n # Calculate the decay factor for each bin based on its index\\n decay_factor = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space for each bin\\n leftover_space = item - bins\\n \\n # Calculate the score for each bin\\n scores = reciprocal_capacity * decay_factor * leftover_space\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that is proportional to the reciprocal of the potential leftover space (item - bin), multiplied by the rest capacity with an additional term that increases exponentially with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * reciprocal_leftover * exp_term\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is inversely proportional to the potential leftover space. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * linear_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity, multiplied by a term that increases exponentially with increasing bin index, and an additional term that is inversely proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the inverse term based on the potential leftover space\\n inv_term = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * exp_term * inv_term\\n \\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins))) * 3\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as the product of the exponential of its rest capacity and the inverse of the item - bin, scaled by a term that increases exponentially with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score of each bin\\n scores = np.exp(-bins) * (1 / (item - bins)) * np.exp(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that decreases exponentially with the increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.02395,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that is proportional to the reciprocal of the potential leftover space (item - bin), multiplied by the rest capacity with an additional term that increases exponentially with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * reciprocal_leftover * exp_term\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is inversely proportional to the potential leftover space. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * linear_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that decreases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_score = np.max(np.log(1 / (bins - item)))\\n \\n # Calculate the linear term that decreases with increasing bin index\\n linear_term = np.arange(len(bins)) * (max_score - 1)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n leftover_space = bins - item\\n \\n # Calculate the final score for each bin\\n scores = max_score + linear_term + leftover_space\\n \\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity, multiplied by a term that increases exponentially with increasing bin index, and an additional term that is inversely proportional to the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential term based on the bin index\\n exp_term = np.exp(np.arange(len(bins)))\\n \\n # Calculate the inverse term based on the potential leftover space\\n inv_term = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * exp_term * inv_term\\n \\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign item to the bin with maximum score calculated by dividing the logarithmic inverse of the remaining bin capacity by the exponential of the bin capacity multiplied by bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic inverse of the remaining bin capacity\\n log_inv_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential of the bin capacity multiplied by the bin index\\n exp_bin_index = np.exp(bins * np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = log_inv_capacity / exp_bin_index\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as the product of the exponential of its rest capacity and the inverse of the item - bin, scaled by a term that increases exponentially with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score of each bin\\n scores = np.exp(-bins) * (1 / (item - bins)) * np.exp(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the sum of the reciprocal root of the remaining capacity and a term proportional to the maximum potential leftover space, multiplied by a decreasing linear term with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the reciprocal root of the remaining capacity and a term proportional to the maximum potential leftover space\\n scores = np.sum(np.reciprocal(np.sqrt(bins - item))) + np.max(bins) * (1 - np.reciprocal(np.sqrt(bins - item)))\\n \\n # Multiply by a decreasing linear term with increasing bin index\\n scores *= np.linspace(1, 0, len(bins))\\n \\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that decreases exponentially with the increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.02395,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that is proportional to the reciprocal of the potential leftover space (item - bin), multiplied by the rest capacity with an additional term that increases exponentially with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * reciprocal_leftover * exp_term\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is inversely proportional to the potential leftover space. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * linear_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by multiplying the reciprocal of the difference between the item size and the bin size with a term that decays as a power function of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the item size and the bin size\\n diff = 1 / (item - bins)\\n \\n # Calculate the decay term based on the bin index\\n decay = np.power(0.5, np.arange(len(bins)))\\n \\n # Multiply the two terms together to get the final score\\n scores = diff * decay\\n \\n return scores\",\n \"objective\": 0.03411,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin based on the inverse of its rest capacity multiplied by a term that increases exponentially with increasing bin index; however, the inverse of the rest capacity is raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity ** exp_term\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign item to the bin with maximum score calculated by dividing the logarithmic inverse of the remaining bin capacity by the exponential of the bin capacity multiplied by bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic inverse of the remaining bin capacity\\n log_inv_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the exponential of the bin capacity multiplied by the bin index\\n exp_bin_index = np.exp(bins * np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = log_inv_capacity / exp_bin_index\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is proportional to the potential leftover space if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the potential leftover space if the item is assigned to the bin\\n potential_leftover = bins - item\\n \\n # Calculate the final score for each bin\\n scores = log_recip_capacity * linear_term + potential_leftover\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the potential leftover space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * (bins - item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as the product of the exponential of its rest capacity and the inverse of the item - bin, scaled by a term that increases exponentially with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score of each bin\\n scores = np.exp(-bins) * (1 / (item - bins)) * np.exp(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the sum of the reciprocal root of the remaining capacity and a term proportional to the maximum potential leftover space, multiplied by a decreasing linear term with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the reciprocal root of the remaining capacity and a term proportional to the maximum potential leftover space\\n scores = np.sum(np.reciprocal(np.sqrt(bins - item))) + np.max(bins) * (1 - np.reciprocal(np.sqrt(bins - item)))\\n \\n # Multiply by a decreasing linear term with increasing bin index\\n scores *= np.linspace(1, 0, len(bins))\\n \\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin having the highest score calculated by dividing the square root of the inverse of the remaining capacity by the exponential of the bin's capacity multiplied by the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(bins * np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A modified version of the provided algorithm that incorporates the item size as a factor to prioritize bins with sufficient remaining capacity and assigns a constant penalty to bins that are full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are full\\n penalties = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Prioritize bins with sufficient remaining capacity\\n priorities = np.where(remaining_capacity >= item, 1, 0)\\n \\n # Combine the penalties and priorities into a single score\\n scores = penalties + priorities\\n \\n return scores\",\n \"objective\": 0.0171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin; however, the exponential term is multiplied by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the square root of the inverse of the remaining capacity and the exponential of the product of the bin index and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins - item)) * np.exp(np.arange(len(bins)) * item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is inversely proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (item - bins + 1)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * exp_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: A modified score function that penalizes bins that are nearly full and prioritizes bins with sufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins that are nearly full (i.e., have less than 10% remaining capacity)\\n penalty = np.where(remaining_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins with sufficient remaining capacity (i.e., have at least 50% remaining capacity)\\n priority = np.where(remaining_capacity >= 0.5 * bins, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the sum of the inverse of its rest capacity and a term that decreases exponentially with increasing bin index, with an additional term that is proportional to the reciprocal of the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * reciprocal_leftover\\n \\n return scores\",\n \"objective\": 0.02395,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign a score to each bin based on the sum of the inverse of its rest capacity and a term that is proportional to the reciprocal of the potential leftover space (item - bin), multiplied by the rest capacity with an additional term that increases exponentially with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the reciprocal of the potential leftover space\\n reciprocal_leftover = 1 / (item - bins)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * reciprocal_leftover * exp_term\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm adds a random noise ranging from 0 to 0.5 to the inverse ratio between the remaining capacity of a bin and the item size, then multiplied by the same weight function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse ratio between the remaining capacity of a bin and the item size\\n inv_ratios = 1 / (bins - item)\\n \\n # Add a random noise ranging from 0 to 0.5 to the inverse ratio\\n noisy_inv_ratios = inv_ratios + np.random.uniform(0, 0.5, size=bins.shape)\\n \\n # Multiply the noisy inverse ratios by the same weight function\\n weights = np.ones(bins.shape) * 0.5\\n scores = noisy_inv_ratios * weights\\n \\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Assign an item to the bin with the maximum score of the logarithm of the reciprocal of the remaining capacity multiplied by a term that increases linearly with increasing bin index, and an additional term that is inversely proportional to the potential leftover space. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithm of the reciprocal of the remaining capacity\\n log_recip_capacity = np.log(1 / (bins - item))\\n \\n # Calculate the linear term that increases with increasing bin index\\n linear_term = np.arange(len(bins)) + 1\\n \\n # Calculate the inverse of the potential leftover space\\n inv_potential_leftover = 1 / (bins - item)\\n \\n # Combine the terms to get the final score\\n scores = log_recip_capacity * linear_term * inv_potential_leftover\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function is a product of the inverse of the ratio between the rest capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the rest capacity of a bin and the item size\\n inv_ratios = 1 / (bins - item)\\n \\n # Calculate the exponential weight based on the bin index\\n weights = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the inverse ratios and weights to get the final scores\\n scores = inv_ratios * weights\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score of each bin is calculated as the product of the inverse of its rest capacity and a weight that is inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the weight for each bin based on its index\\n weight = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * weight\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: The score for each bin is calculated as the square root of the inverse of its rest capacity multiplied by the square of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins + 1)) * np.square(1 / (item + 1))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{ The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.2 times the weight of the previous bin. }\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the remaining capacity of a bin and the item size\\n inv_ratios = np.divide(np.ones(len(bins)), np.subtract(bins, item))\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.2, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(inv_ratios, weights)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is calculated as the product of the bin\\u2019s rest capacity and exponential decay function of the bin\\u2019s index, divided by the distance between the item size and the bin\\u2019s size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the exponential decay function of the bin's index\\n decay_function = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Calculate the score for each bin\\n scores = rest_capacity * decay_function / (item - bins)\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the bin scores by multiplying the rest capacity by the squared inverse of the bin's index, and then dividing by the sum of the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = np.multiply(bins, 1 / (np.square(np.arange(len(bins)) + 1)))\\n \\n # Normalize the scores\\n scores = scores / np.sum(scores)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new scoring function will calculate the score for each bin by multiplying the rest capacity with the inverse of the bin's index to prioritize bins with more rest capacity and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.multiply(bins, 1 / (np.arange(len(bins)) + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Modify the score by adding the inverse of the bin's index to the product of the rest capacity and the inverse of its index to promote bins with higher rest capacities and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's index\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the product of the rest capacity and the inverse of its index\\n prod = bins * inv_index\\n \\n # Add the inverse of the bin's index to the product\\n scores = prod + inv_index\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins farther from the item size using a Gaussian distribution function for the priority and a linear decay function for the penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the prioritization factor based on the remaining capacity of the bins\\n prioritization_factor = np.exp(-np.square(bins - item) / (2 * np.square(item)))\\n \\n # Calculate the penalty factor based on the distance between the item size and the bin sizes\\n penalty_factor = np.abs(bins - item)\\n \\n # Combine the prioritization and penalty factors to get the final score\\n scores = prioritization_factor * (1 - penalty_factor)\\n \\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function is a product of the inverse of the ratio between the rest capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the rest capacity of a bin and the item size\\n inv_ratios = 1 / (bins - item)\\n \\n # Calculate the exponential weight based on the bin index\\n weights = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the inverse ratios and weights to get the final scores\\n scores = inv_ratios * weights\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Modified Algorithm: The score for each bin is calculated as the product of the inverse of its index multiplied by the inverse of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the index and rest capacity for each bin\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_index * inv_rest_capacity\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the inverse of its rest capacity and the inverse of the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the inverse of the sum of the index and the item size\\n inv_sum = 1 / (np.arange(len(bins)) + item)\\n \\n # Multiply the two inverse quantities to get the score for each bin\\n scores = inv_rest_capacity * inv_sum\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: The score for each bin is calculated as the square root of the inverse of the sum of the square of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins + item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{ The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.2 times the weight of the previous bin. }\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the remaining capacity of a bin and the item size\\n inv_ratios = np.divide(np.ones(len(bins)), np.subtract(bins, item))\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.2, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(inv_ratios, weights)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is calculated as the product of the bin\\u2019s rest capacity and exponential decay function of the bin\\u2019s index, divided by the distance between the item size and the bin\\u2019s size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the exponential decay function of the bin's index\\n decay_function = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Calculate the score for each bin\\n scores = rest_capacity * decay_function / (item - bins)\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by multiplying the remaining capacity by the inverse of the item size and adding the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.multiply(bins - item, 1 / (item + 1)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the bin scores by multiplying the rest capacity by the squared inverse of the bin's index, and then dividing by the sum of the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = np.multiply(bins, 1 / (np.square(np.arange(len(bins)) + 1)))\\n \\n # Normalize the scores\\n scores = scores / np.sum(scores)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by multiplying the remaining capacity by the inverse of the item size and subtracting the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.multiply(bins - item, 1 / (item + 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04296,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function is a product of the inverse of the ratio between the rest capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the rest capacity of a bin and the item size\\n inv_ratios = 1 / (bins - item)\\n \\n # Calculate the exponential weight based on the bin index\\n weights = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the inverse ratios and weights to get the final scores\\n scores = inv_ratios * weights\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Modified Algorithm: The score for each bin is calculated as the product of the inverse of its index multiplied by the inverse of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the index and rest capacity for each bin\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_index * inv_rest_capacity\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the inverse of its rest capacity and the inverse of the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the inverse of the sum of the index and the item size\\n inv_sum = 1 / (np.arange(len(bins)) + item)\\n \\n # Multiply the two inverse quantities to get the score for each bin\\n scores = inv_rest_capacity * inv_sum\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: The score for each bin is calculated as the square root of the inverse of the sum of the square of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(1 / (bins + item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{ The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.2 times the weight of the previous bin. }\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the remaining capacity of a bin and the item size\\n inv_ratios = np.divide(np.ones(len(bins)), np.subtract(bins, item))\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.2, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(inv_ratios, weights)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is calculated as the product of the bin\\u2019s rest capacity and exponential decay function of the bin\\u2019s index, divided by the distance between the item size and the bin\\u2019s size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the exponential decay function of the bin's index\\n decay_function = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Calculate the score for each bin\\n scores = rest_capacity * decay_function / (item - bins)\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the sum of a linear function of the bin's size and a logarithmic function of the rest capacity, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the linear function of the bin's size\\n linear_function = np.sum(bins) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the logarithmic function of the rest capacity\\n logarithmic_function = np.log(bins / np.max(bins))\\n \\n # Calculate the score for each bin\\n scores = (linear_function + logarithmic_function) / (item - np.min(bins))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by multiplying the remaining capacity by the inverse of the item size and adding the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.multiply(bins - item, 1 / (item + 1)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as the ratio of its residual capacity to its distance from the item size, and apply random sampling to break ties.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.divide(bins - item, bins)\\n \\n # Apply random sampling to break ties\\n scores = np.random.permutation(scores)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function is a product of the inverse of the ratio between the rest capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the rest capacity of a bin and the item size\\n inv_ratios = 1 / (bins - item)\\n \\n # Calculate the exponential weight based on the bin index\\n weights = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the inverse ratios and weights to get the final scores\\n scores = inv_ratios * weights\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Modified Algorithm: The score for each bin is calculated as the product of the inverse of its index multiplied by the inverse of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the index and rest capacity for each bin\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_index * inv_rest_capacity\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the inverse of its rest capacity and the inverse of the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the inverse of the sum of the index and the item size\\n inv_sum = 1 / (np.arange(len(bins)) + item)\\n \\n # Multiply the two inverse quantities to get the score for each bin\\n scores = inv_rest_capacity * inv_sum\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the square of the inverse of its rest capacity divided by the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.square(np.divide(1, bins)) / (np.sum(bins) + item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{ The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.2 times the weight of the previous bin. }\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the remaining capacity of a bin and the item size\\n inv_ratios = np.divide(np.ones(len(bins)), np.subtract(bins, item))\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.2, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(inv_ratios, weights)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score for each bin as the inverse of the product of its rest capacity and the sum of its index and the item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.divide(1, np.multiply(bins, np.add(np.arange(len(bins)), item)))\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm description: { The new algorithm uses a score function that is the sum of the inverse of the ratio between the remaining capacity of a bin and the item size, multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.1 times the weight of the previous bin. } \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the ratio between the remaining capacity of a bin and the item size\\n ratios = np.divide(bins, item)\\n inv_ratios = np.reciprocal(ratios)\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.1, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(inv_ratios, weights)\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the sum of a linear function of the bin's size and a logarithmic function of the rest capacity, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the linear function of the bin's size\\n linear_function = np.sum(bins) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the logarithmic function of the rest capacity\\n logarithmic_function = np.log(bins / np.max(bins))\\n \\n # Calculate the score for each bin\\n scores = (linear_function + logarithmic_function) / (item - np.min(bins))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by multiplying the remaining capacity by the inverse of the item size and adding the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.multiply(bins - item, 1 / (item + 1)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin proportional to the reciprocal of its rest capacity, multiplied by a term that decays rapidly with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity for each bin\\n reciprocal_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the decay term for each bin\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Modified Algorithm: The score for each bin is calculated as the product of the inverse of its index multiplied by the inverse of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the index and rest capacity for each bin\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_index * inv_rest_capacity\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the inverse of its rest capacity and the inverse of the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the inverse of the sum of the index and the item size\\n inv_sum = 1 / (np.arange(len(bins)) + item)\\n \\n # Multiply the two inverse quantities to get the score for each bin\\n scores = inv_rest_capacity * inv_sum\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the square of the inverse of its rest capacity divided by the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.square(np.divide(1, bins)) / (np.sum(bins) + item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm calculates score as the sum of the reciprocals of the differences between the bin's remaining and maximum capacities and the item size, multiplied by a weight that is exponentially proportional to the bin index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin's remaining and maximum capacities\\n diff = bins - item\\n \\n # Calculate the reciprocal of the difference\\n recip = 1 / (diff + 1)\\n \\n # Calculate the exponential weight based on the bin index\\n weight = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the reciprocal and weight arrays element-wise\\n scores = recip * weight\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function is calculated by subtracting the bin index from the difference between the maximum capacity and the rest capacity of the bin, multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the maximum capacity and the rest capacity of each bin\\n diff = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if diff[i] > 0:\\n scores[i] = (diff[i] - bins[i]) * item\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score for each bin as the inverse of the product of its rest capacity and the sum of its index and the item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.divide(1, np.multiply(bins, np.add(np.arange(len(bins)), item)))\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin proportional to the reciprocal of its rest capacity, multiplied by a term that decays rapidly with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity for each bin\\n reciprocal_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the decay term for each bin\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Modified Algorithm: The score for each bin is calculated as the product of the inverse of its index multiplied by the inverse of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the index and rest capacity for each bin\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_index * inv_rest_capacity\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the inverse of its rest capacity and the inverse of the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the inverse of the sum of the index and the item size\\n inv_sum = 1 / (np.arange(len(bins)) + item)\\n \\n # Multiply the two inverse quantities to get the score for each bin\\n scores = inv_rest_capacity * inv_sum\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the square of the inverse of its rest capacity divided by the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.square(np.divide(1, bins)) / (np.sum(bins) + item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm calculates score as the sum of the reciprocals of the differences between the bin's remaining and maximum capacities and the item size, multiplied by a weight that is exponentially proportional to the bin index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin's remaining and maximum capacities\\n diff = bins - item\\n \\n # Calculate the reciprocal of the difference\\n recip = 1 / (diff + 1)\\n \\n # Calculate the exponential weight based on the bin index\\n weight = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the reciprocal and weight arrays element-wise\\n scores = recip * weight\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function is calculated by subtracting the bin index from the difference between the maximum capacity and the rest capacity of the bin, multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the maximum capacity and the rest capacity of each bin\\n diff = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if diff[i] > 0:\\n scores[i] = (diff[i] - bins[i]) * item\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score for each bin as the inverse of the product of its rest capacity and the sum of its index and the item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.divide(1, np.multiply(bins, np.add(np.arange(len(bins)), item)))\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Assign a score to each bin based on the product of the inverse of its rest capacity and a term that increases exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential term\\n exp_term = np.exp(np.arange(len(bins)) * np.log(inv_rest_capacity))\\n \\n # Calculate the potential leftover space for each bin\\n potential_leftover = item - bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * exp_term * potential_leftover\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by remaining space and penalized by distance from the item size using a Guassian distribution function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining space in each bin\\n remaining_space = bins - item\\n \\n # Penalize bins that are already full\\n penalties = np.where(remaining_space <= 0, 1e9, 0)\\n \\n # Calculate the Gaussian distribution function for each bin\\n gaussian_dist = np.exp(-((remaining_space - item) ** 2) / (2 * (item ** 2)))\\n \\n # Combine the penalties and Gaussian distribution functions\\n scores = penalties + gaussian_dist\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 2 and the weight of each subsequent bin is 1.3 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.3, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm uses a score function that is the product of the inverse of the ratio between the remaining capacity of a bin and the item size multiplied by a weight that is exponentially proportional to the bin index, where the weight for the first bin is 3 and the weight of each subsequent bin is 1.5 times the weight of the previous bin. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the ratio between the remaining capacity and the item size\\n ratio = remaining_capacity / item\\n \\n # Calculate the weight for each bin based on its index\\n weights = np.power(1.5, np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = np.multiply(ratio, weights)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm multiplies the inverse of the bin's rest capacity by the power function of the bin's size weighted by its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin's rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the power function of the bin's size weighted by its index\\n power_function = np.power(bins, np.arange(len(bins)))\\n \\n # Multiply the inverse of the bin's rest capacity by the power function\\n scores = inv_rest_capacity * power_function\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score based on the product of the exponential of the difference between the item size and bin capacity and the penalty for distance from the optimal item size\\n scores = np.exp(-np.abs(item - bins)) * (1 - np.abs(item - bins) / item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to each bin based on the reciprocal of its rest capacity, multiplied by a term that decays exponentially with increasing bin index, with an additional term that is proportional to the potential leftover space (item - bin) if the item is assigned to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity of each bin\\n reciprocal_rest_capacity = 1 / (bins + 1)\\n \\n # Calculate the exponential decay term\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the potential leftover space if the item is assigned to each bin\\n potential_leftover_space = item - bins\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term * potential_leftover_space\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score to each bin proportional to the reciprocal of its rest capacity, multiplied by a term that decays rapidly with increasing bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the rest capacity for each bin\\n reciprocal_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the decay term for each bin\\n decay_term = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Calculate the final score for each bin\\n scores = reciprocal_rest_capacity * decay_term\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index squared\\n scores = np.exp(-bins / (item + 1)) * (1 - (bins / (item + 1)) ** 2)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is computed as the product of a bin preference factor, inversely proportional to the bin's index, and a bin capacity factor, inversely proportional to the difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the bin preference factor\\n pref_factor = 1 / (np.arange(len(bins)) + 1)\\n \\n # Compute the bin capacity factor\\n cap_factor = 1 / (bins - item)\\n \\n # Compute the score for each bin\\n scores = pref_factor * cap_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the exponential decay function of its rest capacity and a weight inversely proportional to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the exponential decay function\\n # of its rest capacity and a weight inversely proportional to its index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = np.exp(-weights * (bins - item))\\n \\n # Remove bins that are at full capacity\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the combination of the inverse of its rest capacity and the square root of the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the square root of the inverse of the index for each bin\\n sqrt_inv_index = np.sqrt(1 / (np.arange(len(bins)) + 1))\\n \\n # Combine the two scores using element-wise multiplication\\n scores = inv_rest_capacity * sqrt_inv_index\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the bin's size, divided by the difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the exponential decay function of the bin's size\\n decay_function = np.exp(-np.log(rest_capacity))\\n \\n # Calculate the score for each bin\\n scores = decay_function * rest_capacity / (item - rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less remaining capacity and penalize bins closer to the item size using a linear decay function for the penalty and a Gaussian distribution function for the priority.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with less remaining capacity\\n priority = np.exp(-remaining_capacity)\\n \\n # Penalize bins closer to the item size\\n penalty = np.exp(-np.abs(remaining_capacity - item))\\n \\n # Combine the priority and penalty to get the final score\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel algorithm combines the inverse of the rest capacity with a logarithmic transformation of the bin's index and then scales it by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a logarithmic transformation to the bin's index\\n log_index = np.log(np.arange(len(bins)))\\n \\n # Scale the logarithmic transformation by the item size\\n scaled_log_index = log_index * item\\n \\n # Combine the inverse of the rest capacity and the scaled logarithmic transformation\\n scores = inv_rest_capacity + scaled_log_index\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the inverse of its rest capacity and the inverse of the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the inverse of the sum of the index and the item size\\n inv_sum = 1 / (np.arange(len(bins)) + item)\\n \\n # Multiply the two inverse quantities to get the score for each bin\\n scores = inv_rest_capacity * inv_sum\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the square of the inverse of its rest capacity divided by the sum of its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.square(np.divide(1, bins)) / (np.sum(bins) + item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Score is calculated as the product of the bin's rest capacity and exponential decay function of the item size, divided by the difference between the bin's size and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the exponential decay function of the item size\\n decay_function = np.exp(-item / (np.max(bins) + 1))\\n \\n # Calculate the score for each bin\\n scores = rest_capacity * decay_function / (bins - item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the inverse of its rest capacity and the inverse of its index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = 1 / (bin - item) + 1 / (i + 1)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm calculates score as the sum of the reciprocals of the differences between the bin's remaining and maximum capacities and the item size, multiplied by a weight that is exponentially proportional to the bin index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin's remaining and maximum capacities\\n diff = bins - item\\n \\n # Calculate the reciprocal of the difference\\n recip = 1 / (diff + 1)\\n \\n # Calculate the exponential weight based on the bin index\\n weight = np.exp(-np.arange(len(bins)) * 0.5)\\n \\n # Multiply the reciprocal and weight arrays element-wise\\n scores = recip * weight\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin based on the ratio of the item size to the bin's rest capacity, and the more full a bin is, the higher the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the ratio of the item size to the bin's rest capacity\\n scores = np.divide(item, bins)\\n \\n # The more full a bin is, the higher the score\\n scores[np.where(bins == bins.max())] = 0\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the ratio of item size to each bin's rest capacity, then if the ratio is larger than or equal to 0.5, square the ratio; otherwise, set the score to -1 if the bin is full or 0 if the bin is not full to maximize the score of the bins that can take the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item size to each bin's rest capacity\\n ratios = item / bins\\n \\n # Set the score to -1 if the bin is full or 0 if the bin is not full\\n scores = np.where(ratios >= 0.5, np.square(ratios), -1)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores for each bin based on the ratio of the remaining capacity to the total usable capacity, prioritizing bins with higher remaining capacities to maximize space utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to total usable capacity for each bin\\n ratios = (bins - item) / bins\\n \\n # Prioritize bins with higher remaining capacities\\n scores = np.argsort(-ratios)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins based on the ratio of the available capacity to the item size, favoring bins with capacities closely matching the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of available capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Favor bins with capacities closely matching the item size\\n scores = np.where(ratios < 0.5, 1, 0)\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the bin scores as the weighted sum of the normalized remaining capacity, and the difference between the rest capacity of the bin and the item size, with a penalty added for using a new bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the remaining capacity of each bin\\n norm_remaining = (bins - item) / bins\\n \\n # Calculate the difference between the rest capacity and the item size\\n diff = bins - item\\n \\n # Add a penalty for using a new bin\\n penalty = np.where(diff > 0, 1, 0)\\n \\n # Weighted sum of the normalized remaining capacity and the difference\\n scores = np.dot(norm_remaining, diff) + penalty\\n \\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is to calculate a score for each bin based on its rest capacity and its index, with higher rest capacity and a lower index receiving a higher score as follows: score = (rest capacity - 2 * index), returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on its rest capacity and index\\n scores = np.zeros(len(bins))\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity >= item:\\n scores[i] = (bin_capacity - 2 * i)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.07878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the maximum capacity, weighted by the inverse of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to maximum capacity for each bin\\n ratios = (bins - item) / bins\\n \\n # Weight the ratios by the inverse of the bin number\\n weights = 1 / np.arange(1, len(bins) + 1)\\n \\n # Calculate the score for each bin\\n scores = ratios * weights\\n \\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Relate the item size to the bin's capacity and promote bins with larger capacity and sufficient available capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the bin capacity\\n ratios = np.divide(item, bins)\\n \\n # Promote bins with larger capacity and sufficient available capacity\\n scores = np.where(ratios > 0.5, 1 - ratios, 0)\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.10635,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the ratio of item size to bin rest capacity, with an exponential decay factor added in.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the ratio of item size to bin rest capacity\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / bin\\n else:\\n scores[i] = 0\\n \\n # Add an exponential decay factor to the scores\\n decay_factor = 0.95\\n scores *= decay_factor ** (np.arange(len(bins)) + 1)\\n \\n return scores\",\n \"objective\": 0.13321,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm prioritizing bins with less than 10% free capacity and penalizing bins that have more than 60% of the item's capacity while decreasing the penalty term to zero for bins with less than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 30% free capacity\\n penalty = np.where(free_capacity < 0.3 * bins, 0, penalty)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have more than 50% of their capacity and giving a larger penalty to bins that have less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Prioritize bins with more than 50% capacity\\n priority_mask = (available_capacity > bins * 0.5)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 10% free capacity\\n penalization_mask = (available_capacity < bins * 0.1)\\n penalization_score = np.where(penalization_mask, 1, 0)\\n \\n # Combine the priority and penalization scores\\n scores = priority_score + penalization_score\\n \\n return scores\",\n \"objective\": 0.02193,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum free capacity, penalized if the free capacity is at least 50% of the bin, and increase the score if the free capacity is at most 10%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with free capacity at least 50% of the bin\\n penalty = np.where(free_capacity >= 0.5 * bins, 1, 0)\\n \\n # Increase the score for bins with free capacity at most 10%\\n bonus = np.where(free_capacity <= 0.1 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity, but only if the bin's capacity exceeds twice the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n # Normalize the scores to ensure they are between 0 and 1\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizing bins with less than 20% free capacity and penalizing bins that have more than 30% of the item's capacity while decreasing the penalty term to zero for bins with less than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that have more than 30% of the item's capacity\\n penalty = np.where(free_capacity > 0.3 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 40% free capacity\\n penalty = np.where(free_capacity < 0.4 * bins, 0, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm for minimizing the number of used bins: Prioritize bins that can fit the item leaving less than 20% free capacity, and penalize bins that leave more than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 20% free capacity\\n priority_bins = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 40% free capacity\\n penalty_bins = np.where(free_capacity > 0.4 * bins, 1, 0)\\n \\n # Combine the prioritization and penalization scores\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that can fit the item leaving less than 20% free capacity, and penalizing bins that leave more than 40% free capacity based on the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 20% free capacity\\n priority_mask = (free_capacity < 0.2 * bins) & (free_capacity >= 0)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins that leave more than 40% free capacity based on the item size\\n penalty_mask = (free_capacity > 0.4 * bins) & (free_capacity <= 0.6 * bins)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with minimum free capacity, penalized if the free capacity is at least 25% of the bin, and increase the score if the free capacity is at most 5%\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with free capacity at least 25% of the bin\\n penalty = np.where(free_capacity >= 0.25 * bins, 1, 0)\\n \\n # Increase the score for bins with free capacity at most 5%\\n bonus = np.where(free_capacity <= 0.05 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 25% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.25 * bins, 1 + (0.25 - free_capacity / bins), 0)\\n scores = np.where(free_capacity > 0.75 * bins, 1 - (free_capacity - 0.75 * bins) / bins, scores)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Penalize bins with more than 20% excessive capacity and reward bins with more than 65% of their capacity, considering the item's size and the average capacity utilization of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Penalize bins with more than 20% excess capacity\\n penalized_bins = np.where(percent_excess > 20, 0, 1)\\n \\n # Reward bins with more than 65% of their capacity\\n rewarded_bins = np.where(percent_excess > 65, 1, 0)\\n \\n # Combine the penalties and rewards\\n scores = penalized_bins + rewarded_bins\\n \\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalizing bins with more than 15% excessive capacity and rewarding bins with more than 75% of their capacity, considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Reward bins with more than 75% of their capacity\\n rewards = np.where(percent_excess > 75, 1, 0)\\n \\n # Penalize bins with more than 15% excess capacity\\n penalties = np.where(percent_excess > 15, -1, 0)\\n \\n # Combine rewards and penalties to get the final score\\n scores = rewards + penalties\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins that can fit the item leaving less than 30% free capacity, penalized bins that have more than 30% free capacity, and assign a small bonus to bins that leave less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 30% free capacity\\n penalty = np.where(free_capacity > (bins * 0.3), 0, (bins * 0.3) - free_capacity)\\n \\n # Bonus for bins with less than 10% free capacity\\n bonus = np.where(free_capacity < (bins * 0.1), (bins * 0.1) - free_capacity, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm with a score function that penalizes bins with less than 25% capacity, gives priority to bins with less than 15% capacity, and doubles the penalty for bins with less than 5% capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of capacity remaining in each bin\\n percent_remaining = (bins - item) / bins\\n \\n # Penalize bins with less than 25% capacity\\n penalties = np.where(percent_remaining < 0.25, 1, 0)\\n \\n # Give priority to bins with less than 15% capacity\\n priorities = np.where(percent_remaining < 0.15, 2, 1)\\n \\n # Double the penalty for bins with less than 5% capacity\\n double_penalty = np.where(percent_remaining < 0.05, 4, 1)\\n \\n # Calculate the total score for each bin\\n scores = penalties * priorities * double_penalty\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm prioritizing bins with less than 10% free capacity and penalizing bins that have more than 60% of the item's capacity while decreasing the penalty term to zero for bins with less than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 30% free capacity\\n penalty = np.where(free_capacity < 0.3 * bins, 0, penalty)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have more than 50% of their capacity and giving a larger penalty to bins that have less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Prioritize bins with more than 50% capacity\\n priority_mask = (available_capacity > bins * 0.5)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 10% free capacity\\n penalization_mask = (available_capacity < bins * 0.1)\\n penalization_score = np.where(penalization_mask, 1, 0)\\n \\n # Combine the priority and penalization scores\\n scores = priority_score + penalization_score\\n \\n return scores\",\n \"objective\": 0.02193,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum free capacity, penalized if the free capacity is at least 50% of the bin, and increase the score if the free capacity is at most 10%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with free capacity at least 50% of the bin\\n penalty = np.where(free_capacity >= 0.5 * bins, 1, 0)\\n \\n # Increase the score for bins with free capacity at most 10%\\n bonus = np.where(free_capacity <= 0.1 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a certain amount of free space, and penalize bins that have either a very small or a very large amount of free space\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with a certain amount of free space\\n priority = np.where(free_space >= 0.5 * bins, 1, 0)\\n \\n # Penalize bins with a very small or very large amount of free space\\n penalty = np.where((free_space < 0.1 * bins) | (free_space > 0.9 * bins), 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with minimum free capacity, penalized if the free capacity is higher than 15%, and increase the score if the free capacity is at most 2%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Penalize bins with high free capacity\\n penalty = np.where(free_capacity > 15, 1, 0)\\n \\n # Increase the score for bins with low free capacity\\n bonus = np.where(free_capacity <= 2, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates a score for each bin based on the ratio of its free capacity to the item size, penalizing bins with less than 25% capacity and prioritizing bins with more than 50% capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of free capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Penalize bins with less than 25% capacity\\n penalties = np.where(ratios < 0.25, 100, 0)\\n \\n # Prioritize bins with more than 50% capacity\\n bonuses = np.where(ratios > 0.5, 100, 0)\\n \\n # Combine penalties and bonuses into a single score\\n scores = penalties + bonuses\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity, but only if the bin's capacity exceeds twice the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n # Normalize the scores to ensure they are between 0 and 1\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizing bins with less than 20% free capacity and penalizing bins that have more than 30% of the item's capacity while decreasing the penalty term to zero for bins with less than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that have more than 30% of the item's capacity\\n penalty = np.where(free_capacity > 0.3 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 40% free capacity\\n penalty = np.where(free_capacity < 0.4 * bins, 0, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm for minimizing the number of used bins: Prioritize bins that can fit the item leaving less than 20% free capacity, and penalize bins that leave more than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 20% free capacity\\n priority_bins = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 40% free capacity\\n penalty_bins = np.where(free_capacity > 0.4 * bins, 1, 0)\\n \\n # Combine the prioritization and penalization scores\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that can fit the item leaving less than 20% free capacity, and penalizing bins that leave more than 40% free capacity based on the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 20% free capacity\\n priority_mask = (free_capacity < 0.2 * bins) & (free_capacity >= 0)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins that leave more than 40% free capacity based on the item size\\n penalty_mask = (free_capacity > 0.4 * bins) & (free_capacity <= 0.6 * bins)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with minimum free capacity, penalized if the free capacity is at least 25% of the bin, and increase the score if the free capacity is at most 5%\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with free capacity at least 25% of the bin\\n penalty = np.where(free_capacity >= 0.25 * bins, 1, 0)\\n \\n # Increase the score for bins with free capacity at most 5%\\n bonus = np.where(free_capacity <= 0.05 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 25% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.25 * bins, 1 + (0.25 - free_capacity / bins), 0)\\n scores = np.where(free_capacity > 0.75 * bins, 1 - (free_capacity - 0.75 * bins) / bins, scores)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Penalize bins with more than 20% excessive capacity and reward bins with more than 65% of their capacity, considering the item's size and the average capacity utilization of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Penalize bins with more than 20% excess capacity\\n penalized_bins = np.where(percent_excess > 20, 0, 1)\\n \\n # Reward bins with more than 65% of their capacity\\n rewarded_bins = np.where(percent_excess > 65, 1, 0)\\n \\n # Combine the penalties and rewards\\n scores = penalized_bins + rewarded_bins\\n \\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm prioritizing bins with less than 10% free capacity and penalizing bins that have more than 60% of the item's capacity while decreasing the penalty term to zero for bins with less than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 30% free capacity\\n penalty = np.where(free_capacity < 0.3 * bins, 0, penalty)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have more than 50% of their capacity and giving a larger penalty to bins that have less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Prioritize bins with more than 50% capacity\\n priority_mask = (available_capacity > bins * 0.5)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 10% free capacity\\n penalization_mask = (available_capacity < bins * 0.1)\\n penalization_score = np.where(penalization_mask, 1, 0)\\n \\n # Combine the priority and penalization scores\\n scores = priority_score + penalization_score\\n \\n return scores\",\n \"objective\": 0.02193,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum free capacity, penalized if the free capacity is at least 50% of the bin, and increase the score if the free capacity is at most 10%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with free capacity at least 50% of the bin\\n penalty = np.where(free_capacity >= 0.5 * bins, 1, 0)\\n \\n # Increase the score for bins with free capacity at most 10%\\n bonus = np.where(free_capacity <= 0.1 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a certain amount of free space, and penalize bins that have either a very small or a very large amount of free space\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with a certain amount of free space\\n priority = np.where(free_space >= 0.5 * bins, 1, 0)\\n \\n # Penalize bins with a very small or very large amount of free space\\n penalty = np.where((free_space < 0.1 * bins) | (free_space > 0.9 * bins), 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm prioritizes bins that have less than 15% free capacity but have a greater capacity than the given item and penalizes bins that have less than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 15% free capacity\\n priority_mask = (free_capacity < 0.15 * bins) & (bins > item)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 30% free capacity\\n penalty_mask = (free_capacity < 0.3 * bins) & (bins > item)\\n penalty_scores = np.where(penalty_mask, -1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.02525,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with minimum free capacity, penalized if the free capacity is higher than 15%, and increase the score if the free capacity is at most 2%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Penalize bins with high free capacity\\n penalty = np.where(free_capacity > 15, 1, 0)\\n \\n # Increase the score for bins with low free capacity\\n bonus = np.where(free_capacity <= 2, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The modified algorithm calculates a score for each bin based on the ratio of its free capacity to the item size, penalizing bins with less than 25% capacity and prioritizing bins with more than 50% capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of free capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Penalize bins with less than 25% capacity\\n penalties = np.where(ratios < 0.25, 100, 0)\\n \\n # Prioritize bins with more than 50% capacity\\n bonuses = np.where(ratios > 0.5, 100, 0)\\n \\n # Combine penalties and bonuses into a single score\\n scores = penalties + bonuses\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity, but only if the bin's capacity exceeds twice the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n # Normalize the scores to ensure they are between 0 and 1\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that can fit the item leaving less than 5% free capacity, and penalize bins that leave more than 25% free capacity by adding the product of the capacities fulfilling the above conditions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 5% free capacity\\n priority_bins = np.where(free_capacity < (0.05 * bins), 1, 0)\\n \\n # Penalize bins that leave more than 25% free capacity\\n penalty_bins = np.where(free_capacity > (0.25 * bins), 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and exponentially increase the priority term; penalize bins that are over 50% full and quadratically increase the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that are over 50% full\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0) ** 2\\n \\n # Combine the priority and penalty terms\\n scores = priority_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with a free capacity of less than 10% and penalizing those with over 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with a free capacity of less than 10%\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have more than 50% of their capacity and giving a larger penalty to bins that have less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Prioritize bins with more than 50% capacity\\n priority_mask = (available_capacity > bins * 0.5)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 10% free capacity\\n penalization_mask = (available_capacity < bins * 0.1)\\n penalization_score = np.where(penalization_mask, 1, 0)\\n \\n # Combine the priority and penalization scores\\n scores = priority_score + penalization_score\\n \\n return scores\",\n \"objective\": 0.02193,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum free capacity, penalized if the free capacity is at least 50% of the bin, and increase the score if the free capacity is at most 10%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with free capacity at least 50% of the bin\\n penalty = np.where(free_capacity >= 0.5 * bins, 1, 0)\\n \\n # Increase the score for bins with free capacity at most 10%\\n bonus = np.where(free_capacity <= 0.1 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a certain amount of free space, and penalize bins that have either a very small or a very large amount of free space\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with a certain amount of free space\\n priority = np.where(free_space >= 0.5 * bins, 1, 0)\\n \\n # Penalize bins with a very small or very large amount of free space\\n penalty = np.where((free_space < 0.1 * bins) | (free_space > 0.9 * bins), 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm prioritizes bins that have less than 15% free capacity but have a greater capacity than the given item and penalizes bins that have less than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 15% free capacity\\n priority_mask = (free_capacity < 0.15 * bins) & (bins > item)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 30% free capacity\\n penalty_mask = (free_capacity < 0.3 * bins) & (bins > item)\\n penalty_scores = np.where(penalty_mask, -1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.02525,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins that have less than 10% free capacity, penalizes those with more than 80% of the item's capacity, and increases the score by 0.5 if the bin's capacity is greater than the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Increase the score by 0.5 if the bin's capacity is greater than the item's capacity\\n bonus = np.where(bins > item, 0.5, 0)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty + bonus\\n \\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 15% free capacity\\n priority = np.where(free_capacity < 0.15 * bins, 1, 0)\\n \\n # Penalize bins that have more than 70% of the item's capacity\\n penalty = np.where(free_capacity > 0.7 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and exponentially increase the priority term; penalize bins that are over 50% full and quadratically increase the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that are over 50% full\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0) ** 2\\n \\n # Combine the priority and penalty terms\\n scores = priority_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with a free capacity of less than 10% and penalizing those with over 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with a free capacity of less than 10%\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have more than 50% of their capacity and giving a larger penalty to bins that have less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Prioritize bins with more than 50% capacity\\n priority_mask = (available_capacity > bins * 0.5)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 10% free capacity\\n penalization_mask = (available_capacity < bins * 0.1)\\n penalization_score = np.where(penalization_mask, 1, 0)\\n \\n # Combine the priority and penalization scores\\n scores = priority_score + penalization_score\\n \\n return scores\",\n \"objective\": 0.02193,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum free capacity, penalized if the free capacity is at least 50% of the bin, and increase the score if the free capacity is at most 10%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with free capacity at least 50% of the bin\\n penalty = np.where(free_capacity >= 0.5 * bins, 1, 0)\\n \\n # Increase the score for bins with free capacity at most 10%\\n bonus = np.where(free_capacity <= 0.1 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a certain amount of free space, and penalize bins that have either a very small or a very large amount of free space\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with a certain amount of free space\\n priority = np.where(free_space >= 0.5 * bins, 1, 0)\\n \\n # Penalize bins with a very small or very large amount of free space\\n penalty = np.where((free_space < 0.1 * bins) | (free_space > 0.9 * bins), 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm prioritizes bins that have less than 15% free capacity but have a greater capacity than the given item and penalizes bins that have less than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 15% free capacity\\n priority_mask = (free_capacity < 0.15 * bins) & (bins > item)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 30% free capacity\\n penalty_mask = (free_capacity < 0.3 * bins) & (bins > item)\\n penalty_scores = np.where(penalty_mask, -1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.02525,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins that can fit the item with less than 20% free capacity and penalize bins with less than 10% free capacity, while penalizing bins with more than 50% of the item's capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * item, 10, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n bonus = np.where(free_capacity < 0.2 * item, 10, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty += np.where(free_capacity > 0.5 * item, 10, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and exponentially increase the priority term; penalize bins that are over 50% full and quadratically increase the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that are over 50% full\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0) ** 2\\n \\n # Combine the priority and penalty terms\\n scores = priority_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 70% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 70% of the item's capacity\\n penalty = np.where(free_capacity > 0.7 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with a free capacity of less than 10% and penalizing those with over 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with a free capacity of less than 10%\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a free capacity of less than 10% while decreasing the penalty term, and penalizing bins that have more than 75% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority_mask = (free_capacity < 0.1 * bins)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 75% of the item's capacity\\n excess_capacity = np.maximum(0, free_capacity - 0.75 * item)\\n excess_penalty = np.where(excess_capacity > 0, 1, 0)\\n \\n # Combine the priority and excess penalty scores\\n scores = priority_score + excess_penalty\\n \\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with less than 2% free space and penalize bins that have more than 60% of the item's free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 2% free space\\n priority = np.where(free_space < 0.02 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's free space\\n penalty = np.where(free_space > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have more than 50% of their capacity and giving a larger penalty to bins that have less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Prioritize bins with more than 50% capacity\\n priority_mask = (available_capacity > bins * 0.5)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 10% free capacity\\n penalization_mask = (available_capacity < bins * 0.1)\\n penalization_score = np.where(penalization_mask, 1, 0)\\n \\n # Combine the priority and penalization scores\\n scores = priority_score + penalization_score\\n \\n return scores\",\n \"objective\": 0.02193,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while reducing the priority term, and penalizing bins that have more than 60% of the item's capacity with the square of the free capacity value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n prioritized_bins = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalized_bins = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (prioritized_bins + penalized_bins) / 2\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and exponentially increase the priority term; penalize bins that are over 50% full and quadratically increase the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that are over 50% full\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0) ** 2\\n \\n # Combine the priority and penalty terms\\n scores = priority_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 70% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 70% of the item's capacity\\n penalty = np.where(free_capacity > 0.7 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with a free capacity of less than 10% and penalizing those with over 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with a free capacity of less than 10%\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a free capacity of less than 10% while decreasing the penalty term, and penalizing bins that have more than 75% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority_mask = (free_capacity < 0.1 * bins)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 75% of the item's capacity\\n excess_capacity = np.maximum(0, free_capacity - 0.75 * item)\\n excess_penalty = np.where(excess_capacity > 0, 1, 0)\\n \\n # Combine the priority and excess penalty scores\\n scores = priority_score + excess_penalty\\n \\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with less than 2% free space and penalize bins that have more than 60% of the item's free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 2% free space\\n priority = np.where(free_space < 0.02 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's free space\\n penalty = np.where(free_space > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while reducing the priority term, and penalizing bins that have more than 60% of the item's capacity with the square of the free capacity value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n prioritized_bins = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalized_bins = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (prioritized_bins + penalized_bins) / 2\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and exponentially increase the priority term; penalize bins that are over 50% full and quadratically increase the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that are over 50% full\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0) ** 2\\n \\n # Combine the priority and penalty terms\\n scores = priority_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity with different priority and penalty terms based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 70% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 70% of the item's capacity\\n penalty = np.where(free_capacity > 0.7 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, penalize bins that can fit the item without leaving any free capacity, and exponentially increase the priority as the remaining capacity increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n prioritized_bins = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalized_bins = np.where(free_capacity == 0, -1, 0)\\n \\n # Exponentially increase the priority as the remaining capacity increases\\n exponential_priority = np.exp(-np.log(free_capacity))\\n \\n # Combine the prioritization, penalization, and exponential priority\\n scores = prioritized_bins + penalized_bins + exponential_priority\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with a free capacity of less than 10% and penalizing those with over 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with a free capacity of less than 10%\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have a free capacity of less than 10% while decreasing the penalty term, and penalizing bins that have more than 75% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority_mask = (free_capacity < 0.1 * bins)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 75% of the item's capacity\\n excess_capacity = np.maximum(0, free_capacity - 0.75 * item)\\n excess_penalty = np.where(excess_capacity > 0, 1, 0)\\n \\n # Combine the priority and excess penalty scores\\n scores = priority_score + excess_penalty\\n \\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while reducing the priority term, and penalizing bins that have more than 60% of the item's capacity with the square of the free capacity value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n prioritized_bins = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalized_bins = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (prioritized_bins + penalized_bins) / 2\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and exponentially increase the priority term; penalize bins that are over 50% full and quadratically increase the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that are over 50% full\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0) ** 2\\n \\n # Combine the priority and penalty terms\\n scores = priority_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity with different priority and penalty terms based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 70% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 70% of the item's capacity\\n penalty = np.where(free_capacity > 0.7 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalize bins that have more than 70% of the item's capacity with different constants based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority_mask = (free_capacity < 0.1 * bins)\\n priority_score = np.where(priority_mask, 10, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_score = np.where(penalty_mask, 5, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_score + penalty_score\\n \\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, penalize bins that can fit the item without leaving any free capacity, and exponentially increase the priority as the remaining capacity increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n prioritized_bins = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalized_bins = np.where(free_capacity == 0, -1, 0)\\n \\n # Exponentially increase the priority as the remaining capacity increases\\n exponential_priority = np.exp(-np.log(free_capacity))\\n \\n # Combine the prioritization, penalization, and exponential priority\\n scores = prioritized_bins + penalized_bins + exponential_priority\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with a free capacity of less than 10% and penalizing those with over 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with a free capacity of less than 10%\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 85% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 85% of the item's capacity\\n penalty = np.where(free_capacity > (0.85 * item), 1, 0)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < (0.03 * item), 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while reducing the priority term, and penalizing bins that have more than 60% of the item's capacity with the square of the free capacity value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n prioritized_bins = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalized_bins = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (prioritized_bins + penalized_bins) / 2\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: prioritization term (1), penalty term (1), free capacity thresholds (0.05, 0.5). New algorithm: Prioritizes bins with less than 2.5% free capacity, penalizes bins with more than 25% of the item's capacity, and uses different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the prioritization term\\n prioritization_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Calculate the penalty term\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = prioritization_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize bins that have more than 80% of the item's capacity with the square of the free capacity value while increasing the priority term of bins that have less than 2% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the penalty for bins with more than 80% of the item's capacity\\n penalty = np.square(np.clip(free_capacity / (0.8 * item), 0, 1))\\n \\n # Calculate the priority term for bins with less than 2% free capacity\\n priority = np.clip(1 - (free_capacity / (0.02 * item)), 0, 1)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity with different priority and penalty terms based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 70% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 70% of the item's capacity\\n penalty = np.where(free_capacity > 0.7 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalize bins that have more than 70% of the item's capacity with different constants based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority_mask = (free_capacity < 0.1 * bins)\\n priority_score = np.where(priority_mask, 10, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_score = np.where(penalty_mask, 5, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_score + penalty_score\\n \\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, penalize bins that can fit the item without leaving any free capacity, and exponentially increase the priority as the remaining capacity increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n prioritized_bins = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalized_bins = np.where(free_capacity == 0, -1, 0)\\n \\n # Exponentially increase the priority as the remaining capacity increases\\n exponential_priority = np.exp(-np.log(free_capacity))\\n \\n # Combine the prioritization, penalization, and exponential priority\\n scores = prioritized_bins + penalized_bins + exponential_priority\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Assign the score of each bin using a sigmoid function involving the ratio of the item size to the bin's rest capacity, with a higher score for bins closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the bin's rest capacity\\n ratios = item / (bins - item)\\n \\n # Apply the sigmoid function to the ratios\\n scores = 1 / (1 + np.exp(-ratios))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, calculate its ratio of rest capacity to item size; if greater than 1, the score is 0, otherwise, the score is the inverse of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Set the score for each bin based on the ratio\\n scores = np.where(ratios > 1, 0, 1 / ratios)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores for each bin based on the ratio of the remaining capacity to the total usable capacity, prioritizing bins with higher remaining capacities to maximize space utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to total usable capacity for each bin\\n ratios = (bins - item) / bins\\n \\n # Prioritize bins with higher remaining capacities\\n scores = np.argsort(-ratios)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size, down from 0.5 to 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(diff / (item + 1), 0.25)\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-thresholds)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with sufficient capacity and penalize bins with excessive capacity, while considering the item's size to favor bins with capacities closest to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Prioritize bins with sufficient capacity\\n priority_mask = (diff <= 0.5 * item)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with excessive capacity\\n penalty_mask = (diff > 0.5 * item) & (diff < 1.5 * item)\\n penalty_scores = np.where(penalty_mask, 0.5, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n # Normalize the scores to ensure they sum to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins based on the ratio of the available capacity to the item size, favoring bins with capacities closely matching the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of available capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Favor bins with capacities closely matching the item size\\n scores = np.where(ratios < 0.5, 1, 0)\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Adjust the priority and penalty thresholds to prioritize bins with smaller capacity differences, especially when the item size is small.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Prioritize bins with smaller capacity differences\\n priority = np.argsort(diff)\\n \\n # Penalize bins with large capacity differences\\n penalty = np.exp(-np.square(diff))\\n \\n # Combine the priority and penalty scores\\n scores = priority * penalty\\n \\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate scores by dividing each bin's rest capacity by the maximum between the difference between its capacity and the item size and 1, excluding bins at max capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.divide(bins - item, np.maximum(bins - item, 1))\\n \\n # Exclude bins at maximum capacity\\n scores[np.where(bins == bins.max())] = 0\\n \\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the ratio of each bin's rest capacity to the item size, then if the ratio is less than or equal to 0.5, square the ratio; otherwise, set the score to -1 if the bin is full or 0 if the bin is not full to maximize the score of the bins that can take the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of each bin's rest capacity to the item size\\n ratios = (bins / item)\\n \\n # Square the ratio if it is less than or equal to 0.5\\n ratios[ratios <= 0.5] **= 2\\n \\n # Set the score to -1 if the bin is full or 0 if the bin is not full\\n scores = np.where(bins == item, -1, 0)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity and a bonus for bins with minimum capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.zeros(len(bins))\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity >= item:\\n scores[i] = (bin_capacity - item) / (bin_capacity + 1)\\n else:\\n scores[i] = 0\\n \\n # Penalize bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores -= (max_capacity - bins) / (max_capacity + 1)\\n \\n # Bonus for bins with minimum capacity\\n min_capacity = np.min(bins)\\n scores += (min_capacity - bins) / (min_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.06771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with available capacity exceeding a threshold, while considering the item's size to favor bins with capacities closest to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Prioritize bins with available capacity exceeding a threshold\\n threshold = 0.5 * item\\n mask = (diff <= threshold).astype(int)\\n \\n # Favor bins with capacities closest to the item size\\n scores = np.where(mask, diff, 0)\\n \\n return scores\",\n \"objective\": 0.07184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is to calculate a score for each bin based on its rest capacity and its index, with higher rest capacity and a lower index receiving a higher score as follows: score = (rest capacity - 2 * index), returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on its rest capacity and index\\n scores = np.zeros(len(bins))\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity >= item:\\n scores[i] = (bin_capacity - 2 * i)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.07878,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 85% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 85% of the item's capacity\\n penalty = np.where(free_capacity > (0.85 * item), 1, 0)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < (0.03 * item), 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 60% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins that have more than 80% of the item's capacity, but only if their free capacity is greater than 5%, while penalizing bins with less than 6% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 80% of the item's capacity\\n priority = np.where(free_capacity >= 0.8 * item, 1, 0)\\n \\n # Penalize bins with less than 6% free capacity\\n penalty = np.where(free_capacity < 0.06 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: prioritization term (1), penalty term (1), free capacity thresholds (0.05, 0.5). New algorithm: Prioritizes bins with less than 2.5% free capacity, penalizes bins with more than 25% of the item's capacity, and uses different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the prioritization term\\n prioritization_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Calculate the penalty term\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = prioritization_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize bins that have more than 80% of the item's capacity with the square of the free capacity value while increasing the priority term of bins that have less than 2% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the penalty for bins with more than 80% of the item's capacity\\n penalty = np.square(np.clip(free_capacity / (0.8 * item), 0, 1))\\n \\n # Calculate the priority term for bins with less than 2% free capacity\\n priority = np.clip(1 - (free_capacity / (0.02 * item)), 0, 1)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity with different priority and penalty terms based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm reducing penalty for bins with less than 30% capacity and increasing priority for bins with less than 20% capacity while adding a double penalty for bins with less than 10% capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on its remaining capacity\\n scores = np.zeros(len(bins))\\n scores[remaining_capacity >= 0.3 * bins] = 1\\n scores[remaining_capacity < 0.3 * bins] = 0.5\\n scores[remaining_capacity < 0.2 * bins] = 0.75\\n scores[remaining_capacity < 0.1 * bins] = 1.5\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 70% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 70% of the item's capacity\\n penalty = np.where(free_capacity > 0.7 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalize bins that have more than 70% of the item's capacity with different constants based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 10% free capacity\\n priority_mask = (free_capacity < 0.1 * bins)\\n priority_score = np.where(priority_mask, 10, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_score = np.where(penalty_mask, 5, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_score + penalty_score\\n \\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 85% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 85% of the item's capacity\\n penalty = np.where(free_capacity > (0.85 * item), 1, 0)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < (0.03 * item), 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 70% of the item's capacity, where bins with less than 2% free capacity are penalized and those with more than 90% are prioritized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_mask = (free_capacity < 0.05 * bins)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and penalize bins with more than 80% of the item's capacity, while considering the difference between the bin's free capacity and the threshold\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 60% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins that have more than 80% of the item's capacity, but only if their free capacity is greater than 5%, while penalizing bins with less than 6% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 80% of the item's capacity\\n priority = np.where(free_capacity >= 0.8 * item, 1, 0)\\n \\n # Penalize bins with less than 6% free capacity\\n penalty = np.where(free_capacity < 0.06 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: prioritization term (1), penalty term (1), free capacity thresholds (0.05, 0.5). New algorithm: Prioritizes bins with less than 2.5% free capacity, penalizes bins with more than 25% of the item's capacity, and uses different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the prioritization term\\n prioritization_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Calculate the penalty term\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = prioritization_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Newly proposed algorithm: Prioritizes bins with a free capacity close to the item's capacity while penalizing bins with little space remaining.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacity\\n diff = np.abs(item - bins)\\n \\n # Penalize bins with little space remaining\\n penalty = np.where(diff < 0.5 * item, 0, 1)\\n \\n # Prioritize bins with a free capacity close to the item size\\n priority = np.where(diff < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize bins that have more than 80% of the item's capacity with the square of the free capacity value while increasing the priority term of bins that have less than 2% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the penalty for bins with more than 80% of the item's capacity\\n penalty = np.square(np.clip(free_capacity / (0.8 * item), 0, 1))\\n \\n # Calculate the priority term for bins with less than 2% free capacity\\n priority = np.clip(1 - (free_capacity / (0.02 * item)), 0, 1)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 1% free capacity while penalizing bins that have more than 80% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 1% free capacity\\n priority = np.where(free_capacity < 0.01 * bins, 1, 0)\\n \\n # Penalize bins that have more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity with different priority and penalty terms based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 85% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 85% of the item's capacity\\n penalty = np.where(free_capacity > (0.85 * item), 1, 0)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < (0.03 * item), 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 70% of the item's capacity, where bins with less than 2% free capacity are penalized and those with more than 90% are prioritized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_mask = (free_capacity < 0.05 * bins)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and penalize bins with more than 80% of the item's capacity, while considering the difference between the bin's free capacity and the threshold\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 60% of the item's capacity by applying a non-linear penalty.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins that have more than 80% of the item's capacity, but only if their free capacity is greater than 5%, while penalizing bins with less than 6% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 80% of the item's capacity\\n priority = np.where(free_capacity >= 0.8 * item, 1, 0)\\n \\n # Penalize bins with less than 6% free capacity\\n penalty = np.where(free_capacity < 0.06 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: prioritization term (1), penalty term (1), free capacity thresholds (0.05, 0.5). New algorithm: Prioritizes bins with less than 2.5% free capacity, penalizes bins with more than 25% of the item's capacity, and uses different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the prioritization term\\n prioritization_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Calculate the penalty term\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = prioritization_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Newly proposed algorithm: Prioritizes bins with a free capacity close to the item's capacity while penalizing bins with little space remaining.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacity\\n diff = np.abs(item - bins)\\n \\n # Penalize bins with little space remaining\\n penalty = np.where(diff < 0.5 * item, 0, 1)\\n \\n # Prioritize bins with a free capacity close to the item size\\n priority = np.where(diff < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize bins that have more than 80% of the item's capacity with the square of the free capacity value while increasing the priority term of bins that have less than 2% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the penalty for bins with more than 80% of the item's capacity\\n penalty = np.square(np.clip(free_capacity / (0.8 * item), 0, 1))\\n \\n # Calculate the priority term for bins with less than 2% free capacity\\n priority = np.clip(1 - (free_capacity / (0.02 * item)), 0, 1)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 1% free capacity while penalizing bins that have more than 80% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 1% free capacity\\n priority = np.where(free_capacity < 0.01 * bins, 1, 0)\\n \\n # Penalize bins that have more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity with different priority and penalty terms based on the bin's free capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with less than 10% free capacity and prioritizes bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 10% free capacity\\n penalty = np.where(free_capacity < 0.1 * bins, 10, 0)\\n \\n # Prioritize bins that have more than 50% of the item's capacity\\n bonus = np.where(free_capacity > 0.5 * item, 2, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < 0.03 * bins, 1, 0)\\n \\n # Penalize bins with more than 75% of the item's capacity\\n penalty = np.where(free_capacity > 0.75 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 85% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 85% of the item's capacity\\n penalty = np.where(free_capacity > (0.85 * item), 1, 0)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < (0.03 * item), 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 70% of the item's capacity, where bins with less than 2% free capacity are penalized and those with more than 90% are prioritized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_mask = (free_capacity < 0.05 * bins)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and penalize bins with more than 80% of the item's capacity, while considering the difference between the bin's free capacity and the threshold\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have less than 3% free capacity and penalize bins that have more than 95% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < 0.03 * bins, 1, 0)\\n \\n # Penalize bins with more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins that have more than 80% of the item's capacity, but only if their free capacity is greater than 5%, while penalizing bins with less than 6% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 80% of the item's capacity\\n priority = np.where(free_capacity >= 0.8 * item, 1, 0)\\n \\n # Penalize bins with less than 6% free capacity\\n penalty = np.where(free_capacity < 0.06 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting less than 5% of the item's capacity from the free capacity and penalize bins that have more than 40% free capacity after adding 10% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Penalize bins with more than 40% free capacity after adding 10% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item + 0.1 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: prioritization term (1), penalty term (1), free capacity thresholds (0.05, 0.5). New algorithm: Prioritizes bins with less than 2.5% free capacity, penalizes bins with more than 25% of the item's capacity, and uses different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the prioritization term\\n prioritization_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Calculate the penalty term\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = prioritization_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Newly proposed algorithm: Prioritizes bins with a free capacity close to the item's capacity while penalizing bins with little space remaining.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacity\\n diff = np.abs(item - bins)\\n \\n # Penalize bins with little space remaining\\n penalty = np.where(diff < 0.5 * item, 0, 1)\\n \\n # Prioritize bins with a free capacity close to the item size\\n priority = np.where(diff < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 7% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 7% free capacity\\n priority = np.where(free_capacity < 0.07 * bins, 1, 0)\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize bins that have more than 80% of the item's capacity with the square of the free capacity value while increasing the priority term of bins that have less than 2% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the penalty for bins with more than 80% of the item's capacity\\n penalty = np.square(np.clip(free_capacity / (0.8 * item), 0, 1))\\n \\n # Calculate the priority term for bins with less than 2% free capacity\\n priority = np.clip(1 - (free_capacity / (0.02 * item)), 0, 1)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < 0.03 * bins, 1, 0)\\n \\n # Penalize bins with more than 75% of the item's capacity\\n penalty = np.where(free_capacity > 0.75 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 85% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 85% of the item's capacity\\n penalty = np.where(free_capacity > (0.85 * item), 1, 0)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < (0.03 * item), 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 40% free capacity and penalize bins with more than 5%\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 40% free capacity\\n priority = np.where(free_capacity > 0.4 * bins, 1, 0)\\n \\n # Penalize bins with more than 5% free capacity\\n penalty = np.where(free_capacity > 0.05 * bins, -1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 70% of the item's capacity, where bins with less than 2% free capacity are penalized and those with more than 90% are prioritized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_mask = (free_capacity < 0.05 * bins)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and penalize bins with more than 80% of the item's capacity, while considering the difference between the bin's free capacity and the threshold\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have less than 5% free capacity and penalize bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 100, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 100, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have less than 3% free capacity and penalize bins that have more than 95% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < 0.03 * bins, 1, 0)\\n \\n # Penalize bins with more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins that have more than 80% of the item's capacity, but only if their free capacity is greater than 5%, while penalizing bins with less than 6% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 80% of the item's capacity\\n priority = np.where(free_capacity >= 0.8 * item, 1, 0)\\n \\n # Penalize bins with less than 6% free capacity\\n penalty = np.where(free_capacity < 0.06 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting less than 5% of the item's capacity from the free capacity and penalize bins that have more than 40% free capacity after adding 10% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Penalize bins with more than 40% free capacity after adding 10% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item + 0.1 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: prioritization term (1), penalty term (1), free capacity thresholds (0.05, 0.5). New algorithm: Prioritizes bins with less than 2.5% free capacity, penalizes bins with more than 25% of the item's capacity, and uses different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the prioritization term\\n prioritization_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Calculate the penalty term\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = prioritization_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Newly proposed algorithm: Prioritizes bins with a free capacity close to the item's capacity while penalizing bins with little space remaining.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacity\\n diff = np.abs(item - bins)\\n \\n # Penalize bins with little space remaining\\n penalty = np.where(diff < 0.5 * item, 0, 1)\\n \\n # Prioritize bins with a free capacity close to the item size\\n priority = np.where(diff < 0.1 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < 0.03 * bins, 1, 0)\\n \\n # Penalize bins with more than 75% of the item's capacity\\n penalty = np.where(free_capacity > 0.75 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalizing bins that have more than 60% of the item's capacity while increasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that have more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 5% free capacity and penalizing bins that exceed 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins that exceed 75% of the item's capacity\\n penalty = np.where(free_capacity > 0.75 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 3% free capacity and penalizing bins that have more than 85% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 85% of the item's capacity\\n penalty = np.where(free_capacity > (0.85 * item), 1, 0)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < (0.03 * item), 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 40% free capacity and penalize bins with more than 5%\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 40% free capacity\\n priority = np.where(free_capacity > 0.4 * bins, 1, 0)\\n \\n # Penalize bins with more than 5% free capacity\\n penalty = np.where(free_capacity > 0.05 * bins, -1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 5% free capacity and penalized bins that have more than 70% of the item's capacity, where bins with less than 2% free capacity are penalized and those with more than 90% are prioritized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority_mask = (free_capacity < 0.05 * bins)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with more than 70% of the item's capacity\\n penalty_mask = (free_capacity > 0.7 * item)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 5% free capacity and penalize bins with more than 80% of the item's capacity, while considering the difference between the bin's free capacity and the threshold\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 80% of the item's capacity\\n penalty = np.where(free_capacity > 0.8 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have less than 5% free capacity and penalize bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Penalize bins with more than 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 100, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 100, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have less than 3% free capacity and penalize bins that have more than 95% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 3% free capacity\\n priority = np.where(free_capacity < 0.03 * bins, 1, 0)\\n \\n # Penalize bins with more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins that have more than 80% of the item's capacity, but only if their free capacity is greater than 5%, while penalizing bins with less than 6% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with more than 80% of the item's capacity\\n priority = np.where(free_capacity >= 0.8 * item, 1, 0)\\n \\n # Penalize bins with less than 6% free capacity\\n penalty = np.where(free_capacity < 0.06 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes bins that have less than 2% free capacity and prioritizes bins that have more than 85% of the item's capacity; while the original algorithm prioritizes bins with less than 15% free capacity and penalizing bins that have more than 70% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 2% free capacity\\n penalty = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Prioritize bins with more than 85% of the item's capacity\\n bonus = np.where(free_capacity > 0.85 * item, 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that penalizes bins with less than 5% free capacity and prioritizes bins that have more than 90% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 5% free capacity\\n penalty = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Prioritize bins with more than 90% of the item's capacity\\n priority = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting less than 5% of the item's capacity from the free capacity and penalize bins that have more than 40% free capacity after adding 10% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Penalize bins with more than 40% free capacity after adding 10% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item + 0.1 * item, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizes bins with less than 5% free capacity and penalizes bins with more than 50% of the item's capacity, with different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 5% free capacity and penalizing bins that have more than 95% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins that have more than 95% of the item's capacity\\n penalty = np.where(free_capacity > 0.95 * item, 1, 0)\\n \\n # Prioritize bins that have less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 2% free capacity and penalizing bins that exceed 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 2% free capacity\\n priority = np.where(free_capacity < 0.02 * bins, 1, 0)\\n \\n # Penalize bins that exceed 90% of the item's capacity\\n penalty = np.where(free_capacity > 0.9 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / 2\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have less than 5% free capacity while increasing the penalty term, and penalizing bins that have more than 50% of the item's capacity with a different penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 5% free capacity\\n priority = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Penalize bins with more than 50% of the item's capacity\\n penalty = np.where(free_capacity > 0.5 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: prioritization term (1), penalty term (1), free capacity thresholds (0.05, 0.5). New algorithm: Prioritizes bins with less than 2.5% free capacity, penalizes bins with more than 25% of the item's capacity, and uses different prioritization and penalty terms based on the bin's free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the prioritization term\\n prioritization_term = np.where(free_capacity < 0.05 * bins, 1, 0)\\n \\n # Calculate the penalty term\\n penalty_term = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = prioritization_term + penalty_term\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 8% free space and penalize bins that have more than 45% of the item's free space, while decreasing the penalty term for bins with less than 55% free space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free space in each bin\\n free_space = bins - item\\n \\n # Prioritize bins with less than 8% free space\\n priority = np.where(free_space < 0.08 * bins, 1, 0)\\n \\n # Penalize bins that have more than 45% of the item's free space\\n penalty = np.where(free_space > 0.45 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 55% free space\\n penalty = np.where(free_space < 0.55 * item, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have more than 50% free capacity, and penalize bins that can fit the item without leaving any free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with more than 50% free capacity\\n priority = np.where(free_capacity > (bins / 2), 1, 0)\\n \\n # Penalize bins that can fit the item without leaving any free capacity\\n penalty = np.where(free_capacity == 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a variable amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold based on the difference\\n fav_thresh = np.minimum(diff / (item + 1), 0.5)\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 - fav_thresh[i]\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New Algorithm: Calculate the score for each bin as the exponential of the non-positive difference between bin's rest capacity and item size, and the rest capacity to the power of the square root of positive differences.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.exp(-np.maximum(0, bins - item)) * (bins ** 0.5)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, calculate its ratio of rest capacity to item size; if greater than 1, the score is 0, otherwise, the score is the inverse of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Set the score for each bin based on the ratio\\n scores = np.where(ratios > 1, 0, 1 / ratios)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with smaller capacity differences and higher available capacities, penalizing bins with large capacity differences or insufficient available capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n capacity_diff = np.abs(bins - item)\\n \\n # Calculate the available capacity for each bin\\n available_capacity = bins - capacity_diff\\n \\n # Prioritize bins with smaller capacity differences and higher available capacities\\n scores = np.zeros(len(bins))\\n scores[available_capacity > 0] = 1 / (1 + np.exp(-available_capacity[available_capacity > 0]))\\n scores[available_capacity <= 0] = 0\\n \\n # Penalize bins with large capacity differences or insufficient available capacity\\n scores[capacity_diff > 1] -= 1\\n scores[available_capacity < 0] -= 1\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with exact capacity and penalize bins with smaller capacities, favoring larger bins with sufficient space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = bins - item\\n \\n # Penalize bins with smaller capacities by adding a large negative value\\n penalty = np.where(diff < 0, -1e9, 0)\\n \\n # Favor bins with exact capacity by adding a positive value\\n bonus = np.where(diff == 0, 1e9, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a very high score to bins that exactly fit the item's size, while for all other less-fitting bins, calculate scores based on the difference in capacities and item size, with a penalty for bins exceeding the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin sizes\\n diff = np.abs(item - bins)\\n \\n # Calculate the penalty for bins that exceed the item size\\n penalty = np.maximum(0, diff - item)\\n \\n # Calculate the score for each bin\\n scores = np.where(diff == 0, np.inf, 1 / (1 + penalty))\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores for each bin based on the ratio of the remaining capacity to the total usable capacity, prioritizing bins with higher remaining capacities to maximize space utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to total usable capacity for each bin\\n ratios = (bins - item) / bins\\n \\n # Prioritize bins with higher remaining capacities\\n scores = np.argsort(-ratios)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of item size and the reciprocal of (the rest capacity plus one)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.multiply(item, np.reciprocal(bins + 1))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size, down from 0.5 to 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(diff / (item + 1), 0.25)\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-thresholds)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with sufficient capacity and penalize bins with excessive capacity, while considering the item's size to favor bins with capacities closest to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Prioritize bins with sufficient capacity\\n priority_mask = (diff <= 0.5 * item)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with excessive capacity\\n penalty_mask = (diff > 0.5 * item) & (diff < 1.5 * item)\\n penalty_scores = np.where(penalty_mask, 0.5, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n # Normalize the scores to ensure they sum to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins based on the ratio of the available capacity to the item size, favoring bins with capacities closely matching the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of available capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Favor bins with capacities closely matching the item size\\n scores = np.where(ratios < 0.5, 1, 0)\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm scores each bin based on the product of the bin's index and the number of available bins with equal or larger capacity, prioritizing bins with lower indices and higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the bin's index and the number of available bins with equal or larger capacity\\n scores = np.array([bin_index * (len(bins) - bin_index) for bin_index in range(len(bins))])\\n \\n # Prioritize bins with lower indices and higher capacities\\n scores[np.where(bins < item)] = 0\\n \\n return scores\",\n \"objective\": 0.04477,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Adjust the priority and penalty thresholds to prioritize bins with smaller capacity differences, especially when the item size is small.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Prioritize bins with smaller capacity differences\\n priority = np.argsort(diff)\\n \\n # Penalize bins with large capacity differences\\n penalty = np.exp(-np.square(diff))\\n \\n # Combine the priority and penalty scores\\n scores = priority * penalty\\n \\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate scores by dividing each bin's rest capacity by the maximum between the difference between its capacity and the item size and 1, excluding bins at max capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.divide(bins - item, np.maximum(bins - item, 1))\\n \\n # Exclude bins at maximum capacity\\n scores[np.where(bins == bins.max())] = 0\\n \\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on the ratio of remaining capacity to the difference between bin capacity and item size, prioritizing bins with both higher remaining capacity and smaller difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to the difference between bin capacity and item size\\n ratios = (bins - item) / (bins - np.minimum(bins, item))\\n \\n # Prioritize bins with both higher remaining capacity and smaller difference\\n scores = np.where(ratios > 0, ratios, 0)\\n \\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a variable amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold based on the difference\\n fav_thresh = np.minimum(diff / (item + 1), 0.5)\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 - fav_thresh[i]\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin as the exponential of the non-positive difference between the bin's rest capacity and item size, and the rest capacity to the power of the positive difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.exp(-np.abs(bins - item)) * (bins / item) ** 2\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, calculate its ratio of rest capacity to item size; if greater than 1, the score is 0, otherwise, the score is the inverse of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Set the score for each bin based on the ratio\\n scores = np.where(ratios > 1, 0, 1 / ratios)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with smaller capacity differences and higher available capacities, penalizing bins with large capacity differences or insufficient available capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n capacity_diff = np.abs(bins - item)\\n \\n # Calculate the available capacity for each bin\\n available_capacity = bins - capacity_diff\\n \\n # Prioritize bins with smaller capacity differences and higher available capacities\\n scores = np.zeros(len(bins))\\n scores[available_capacity > 0] = 1 / (1 + np.exp(-available_capacity[available_capacity > 0]))\\n scores[available_capacity <= 0] = 0\\n \\n # Penalize bins with large capacity differences or insufficient available capacity\\n scores[capacity_diff > 1] -= 1\\n scores[available_capacity < 0] -= 1\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: item size, bin capacity. New algorithm: For each bin, calculate its score as the difference between its rest capacity and the item size, if positive, the score is 0, otherwise, the score is the inverse of the difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the rest capacity and the item size\\n diff = bins - item\\n \\n # Set the score to 0 if the difference is positive, otherwise set it to the inverse of the difference\\n scores = np.where(diff > 0, 0, 1 / diff)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a very high score to bins that exactly fit the item's size, while for all other less-fitting bins, calculate scores based on the difference in capacities and item size, with a penalty for bins exceeding the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin sizes\\n diff = np.abs(item - bins)\\n \\n # Calculate the penalty for bins that exceed the item size\\n penalty = np.maximum(0, diff - item)\\n \\n # Calculate the score for each bin\\n scores = np.where(diff == 0, np.inf, 1 / (1 + penalty))\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores for each bin based on the ratio of the remaining capacity to the total usable capacity, prioritizing bins with higher remaining capacities to maximize space utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to total usable capacity for each bin\\n ratios = (bins - item) / bins\\n \\n # Prioritize bins with higher remaining capacities\\n scores = np.argsort(-ratios)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of item size and the reciprocal of (the rest capacity plus one)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.multiply(item, np.reciprocal(bins + 1))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size, down from 0.5 to 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(diff / (item + 1), 0.25)\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-thresholds)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with sufficient capacity and penalize bins with excessive capacity, while considering the item's size to favor bins with capacities closest to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Prioritize bins with sufficient capacity\\n priority_mask = (diff <= 0.5 * item)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with excessive capacity\\n penalty_mask = (diff > 0.5 * item) & (diff < 1.5 * item)\\n penalty_scores = np.where(penalty_mask, 0.5, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n # Normalize the scores to ensure they sum to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins based on the ratio of the available capacity to the item size, favoring bins with capacities closely matching the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of available capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Favor bins with capacities closely matching the item size\\n scores = np.where(ratios < 0.5, 1, 0)\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm scores each bin based on the product of its index and the number of available bins with equal or larger capacity and lower indices\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the index and the number of available bins with equal or larger capacity and lower indices\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = (i + 1) * (len(bins) - i)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04477,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Adjust the priority and penalty thresholds to prioritize bins with smaller capacity differences, especially when the item size is small.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Prioritize bins with smaller capacity differences\\n priority = np.argsort(diff)\\n \\n # Penalize bins with large capacity differences\\n penalty = np.exp(-np.square(diff))\\n \\n # Combine the priority and penalty scores\\n scores = priority * penalty\\n \\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm with adjusted parameter settings: Prioritizing bins that have more free capacity than the item and penalizing bins that have less than 25% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with less than 25% free capacity\\n penalty = np.where(free_capacity < (0.25 * bins), 1, 0)\\n \\n # Prioritize bins with more free capacity than the item\\n priority = np.where(free_capacity > item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm with adjusted parameter settings: Prioritizing bins with sufficient capacity and penalizing bins with more than 50% excessive capacity while considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Penalize bins with more than 50% excessive capacity\\n penalty = np.where(available_capacity > (bins / 2), 0, 1)\\n \\n # Prioritize bins with sufficient capacity\\n priority = np.where(available_capacity >= item, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty * priority\\n \\n return scores\",\n \"objective\": 0.0484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate scores by dividing each bin's rest capacity by the maximum between the difference between its capacity and the item size and 1, excluding bins at max capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.divide(bins - item, np.maximum(bins - item, 1))\\n \\n # Exclude bins at maximum capacity\\n scores[np.where(bins == bins.max())] = 0\\n \\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 25% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.25 * bins, 1 + (0.25 - free_capacity / bins), 0)\\n scores = np.where(free_capacity > 0.75 * bins, 1 - (free_capacity - 0.75 * bins) / bins, scores)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalizing bins with more than 15% excessive capacity and rewarding bins with more than 75% of their capacity, considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Reward bins with more than 75% of their capacity\\n rewards = np.where(percent_excess > 75, 1, 0)\\n \\n # Penalize bins with more than 15% excess capacity\\n penalties = np.where(percent_excess > 15, -1, 0)\\n \\n # Combine rewards and penalties to get the final score\\n scores = rewards + penalties\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a variable amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold based on the difference\\n fav_thresh = np.minimum(diff / (item + 1), 0.5)\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 - fav_thresh[i]\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin as the natural log of the non-positive difference between the bin's rest capacity and item size, and the rest capacity to the power of the positive difference\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.log(np.abs(bins - item)) + (bins / (bins - item)) ** 2\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin as the exponential of the non-positive difference between the bin's rest capacity and item size, and the rest capacity to the power of the positive difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.exp(-np.abs(bins - item)) * (bins / item) ** 2\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, calculate its ratio of rest capacity to item size; if greater than 1, the score is 0, otherwise, the score is the inverse of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Set the score for each bin based on the ratio\\n scores = np.where(ratios > 1, 0, 1 / ratios)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with smaller capacity differences and higher available capacities, penalizing bins with large capacity differences or insufficient available capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n capacity_diff = np.abs(bins - item)\\n \\n # Calculate the available capacity for each bin\\n available_capacity = bins - capacity_diff\\n \\n # Prioritize bins with smaller capacity differences and higher available capacities\\n scores = np.zeros(len(bins))\\n scores[available_capacity > 0] = 1 / (1 + np.exp(-available_capacity[available_capacity > 0]))\\n scores[available_capacity <= 0] = 0\\n \\n # Penalize bins with large capacity differences or insufficient available capacity\\n scores[capacity_diff > 1] -= 1\\n scores[available_capacity < 0] -= 1\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: item size, bin capacity. New algorithm: For each bin, calculate its score as the difference between its rest capacity and the item size, if positive, the score is 0, otherwise, the score is the inverse of the difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the rest capacity and the item size\\n diff = bins - item\\n \\n # Set the score to 0 if the difference is positive, otherwise set it to the inverse of the difference\\n scores = np.where(diff > 0, 0, 1 / diff)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a very high score to bins that exactly fit the item's size, while for all other less-fitting bins, calculate scores based on the difference in capacities and item size, with a penalty for bins exceeding the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin sizes\\n diff = np.abs(item - bins)\\n \\n # Calculate the penalty for bins that exceed the item size\\n penalty = np.maximum(0, diff - item)\\n \\n # Calculate the score for each bin\\n scores = np.where(diff == 0, np.inf, 1 / (1 + penalty))\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores for each bin based on the ratio of the remaining capacity to the total usable capacity, prioritizing bins with higher remaining capacities to maximize space utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to total usable capacity for each bin\\n ratios = (bins - item) / bins\\n \\n # Prioritize bins with higher remaining capacities\\n scores = np.argsort(-ratios)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of item size and the reciprocal of (the rest capacity plus one)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.multiply(item, np.reciprocal(bins + 1))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size, down from 0.5 to 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(diff / (item + 1), 0.25)\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-thresholds)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The idea is to find which bin has a best score. A bin with more remaining capacity will have a best score. If the remaining capacity is larger than item's size, the score is the inverse of the remaining capacity. If the remaining capacity is smaller than item's size, the score is the inverse of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Initialize the scores for each bin\\n scores = np.zeros(len(bins))\\n \\n # Loop through each bin and calculate its score\\n for i in range(len(bins)):\\n if remaining_capacity[i] >= item:\\n # If the remaining capacity is greater than or equal to the item size,\\n # the score is the inverse of the remaining capacity\\n scores[i] = 1 / remaining_capacity[i]\\n else:\\n # If the remaining capacity is less than the item size,\\n # the score is the inverse of the item size\\n scores[i] = 1 / item\\n \\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins with capacities closer to the item size and penalize bins with excessive capacity, while minimizing the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with excessive capacity\\n penalty = np.maximum(0, (bins - item)) ** 2\\n \\n # Prioritize bins with capacities closer to the item size\\n priority = np.exp(-diff / (item * 0.5))\\n \\n # Combine the penalty and priority scores\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins based on the ratio of the available capacity to the item size, favoring bins with capacities closely matching the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of available capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Favor bins with capacities closely matching the item size\\n scores = np.where(ratios < 0.5, 1, 0)\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04427,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm scores each bin based on the product of its index and the number of available bins with equal or larger capacity and lower indices\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the index and the number of available bins with equal or larger capacity and lower indices\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = (i + 1) * (len(bins) - i)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04477,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize the bin with the closest lower capacity to the item size while penalizing bins exceeding or falling too far below that capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Penalize bins that are too small or too large\\n penalty = np.where(diff > 0.5 * item, 10 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.04487,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 25% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.25 * bins, 1 + (0.25 - free_capacity / bins), 0)\\n scores = np.where(free_capacity > 0.75 * bins, 1 - (free_capacity - 0.75 * bins) / bins, scores)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalizing bins with more than 15% excessive capacity and rewarding bins with more than 75% of their capacity, considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Reward bins with more than 75% of their capacity\\n rewards = np.where(percent_excess > 75, 1, 0)\\n \\n # Penalize bins with more than 15% excess capacity\\n penalties = np.where(percent_excess > 15, -1, 0)\\n \\n # Combine rewards and penalties to get the final score\\n scores = rewards + penalties\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a variable amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold based on the difference\\n fav_thresh = np.minimum(diff / (item + 1), 0.5)\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 - fav_thresh[i]\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin as the natural log of the non-positive difference between the bin's rest capacity and item size, and the rest capacity to the power of the positive difference\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.log(np.abs(bins - item)) + (bins / (bins - item)) ** 2\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the exponential of the negative difference between the ratio of bin's rest capacity and item size, and the ratio to the power of the negative difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.exp(-(bins - item) / (bins + item)) ** 2\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, calculate its ratio of rest capacity to item size; if greater than 1, the score is 0, otherwise, the score is the inverse of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Set the score for each bin based on the ratio\\n scores = np.where(ratios > 1, 0, 1 / ratios)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a fixed amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(0, diff - 1)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 / (thresholds[i] + 1)\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritizing bins that have more than 75% of their capacity and penalizing bins that have less than 25% free capacity \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Penalize bins with less than 25% free capacity\\n penalty = np.where(available_capacity < (0.25 * bins), 1, 0)\\n \\n # Prioritize bins with more than 75% free capacity\\n bonus = np.where(available_capacity > (0.75 * bins), 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: item size, bin capacity. New algorithm: For each bin, calculate its score as the difference between its rest capacity and the item size, if positive, the score is 0, otherwise, the score is the inverse of the difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the rest capacity and the item size\\n diff = bins - item\\n \\n # Set the score to 0 if the difference is positive, otherwise set it to the inverse of the difference\\n scores = np.where(diff > 0, 0, 1 / diff)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a very high score to bins that exactly fit the item's size, while for all other less-fitting bins, calculate scores based on the difference in capacities and item size, with a penalty for bins exceeding the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin sizes\\n diff = np.abs(item - bins)\\n \\n # Calculate the penalty for bins that exceed the item size\\n penalty = np.maximum(0, diff - item)\\n \\n # Calculate the score for each bin\\n scores = np.where(diff == 0, np.inf, 1 / (1 + penalty))\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates scores for each bin based on the ratio of the remaining capacity to the total usable capacity, prioritizing bins with higher remaining capacities to maximize space utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of remaining capacity to total usable capacity for each bin\\n ratios = (bins - item) / bins\\n \\n # Prioritize bins with higher remaining capacities\\n scores = np.argsort(-ratios)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins that have less than 30% free capacity, penalize bins that have more than 80% of the item's capacity, and reward empty bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on the free capacity\\n scores = np.where(free_capacity < 0.3 * bins, 100, 0)\\n scores += np.where(free_capacity > 0.8 * item, -100, 0)\\n scores += np.where(free_capacity == 0, 50, 0)\\n \\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of item size and the reciprocal of (the rest capacity plus one)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.multiply(item, np.reciprocal(bins + 1))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size, down from 0.5 to 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(diff / (item + 1), 0.25)\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-thresholds)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: This algorithm prioritizes bins with a great free capacity and the free capacity is greater than 50% of the bin capacity; penalizing the bins that have less than 50% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with a great free capacity (greater than 50% of the bin capacity)\\n priority = np.where(free_capacity > 0.5 * bins, 1, 0)\\n \\n # Penalize bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have smaller differences between their current capacity and the target capacity, penalizing bins that have large differences or insufficient remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the current capacity and the target capacity for each bin\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with large differences or insufficient remaining capacity\\n penalty = np.where(diff > 0.5 * bins, 10 * diff, 0)\\n penalty += np.where(bins < item, 10 * (item - bins), 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / 10)\\n \\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 50% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.5 * bins, 1, 0) + np.where(free_capacity > 0.9 * item, -1, 0)\\n \\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizing bins with less than 20% free capacity and penalizing bins that have more than 30% of the item's capacity while decreasing the penalty term to zero for bins with less than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that have more than 30% of the item's capacity\\n penalty = np.where(free_capacity > 0.3 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 40% free capacity\\n penalty = np.where(free_capacity < 0.4 * bins, 0, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 25% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.25 * bins, 1 + (0.25 - free_capacity / bins), 0)\\n scores = np.where(free_capacity > 0.75 * bins, 1 - (free_capacity - 0.75 * bins) / bins, scores)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Penalize bins with more than 20% excessive capacity and reward bins with more than 65% of their capacity, considering the item's size and the average capacity utilization of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Penalize bins with more than 20% excess capacity\\n penalized_bins = np.where(percent_excess > 20, 0, 1)\\n \\n # Reward bins with more than 65% of their capacity\\n rewarded_bins = np.where(percent_excess > 65, 1, 0)\\n \\n # Combine the penalties and rewards\\n scores = penalized_bins + rewarded_bins\\n \\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalizing bins with more than 15% excessive capacity and rewarding bins with more than 75% of their capacity, considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Reward bins with more than 75% of their capacity\\n rewards = np.where(percent_excess > 75, 1, 0)\\n \\n # Penalize bins with more than 15% excess capacity\\n penalties = np.where(percent_excess > 15, -1, 0)\\n \\n # Combine rewards and penalties to get the final score\\n scores = rewards + penalties\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a variable amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold based on the difference\\n fav_thresh = np.minimum(diff / (item + 1), 0.5)\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 - fav_thresh[i]\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.1 * bins, 10 * (1 - free_capacity / bins), 0)\\n scores += np.where(free_capacity > 0.5 * bins, -5 * (free_capacity / bins - 0.5), 0)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.1 * bins, 10 * (1 - free_capacity / bins), 0)\\n scores += np.where(free_capacity > 0.9 * bins, -10 * (free_capacity / bins - 0.9), 0)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin as the natural log of the non-positive difference between the bin's rest capacity and item size, and the rest capacity to the power of the positive difference\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.log(np.abs(bins - item)) + (bins / (bins - item)) ** 2\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the exponential of the negative difference between the ratio of bin's rest capacity and item size, and the natural logarithm of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.exp(-np.log(bins / item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, calculate its ratio of rest capacity to item size; if greater than 1, the score is 0, otherwise, the score is the inverse of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Set the score for each bin based on the ratio\\n scores = np.where(ratios > 1, 0, 1 / ratios)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a fixed amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(0, diff - 1)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 / (thresholds[i] + 1)\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritizing bins that have more than 75% of their capacity and penalizing bins that have less than 25% free capacity \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Penalize bins with less than 25% free capacity\\n penalty = np.where(available_capacity < (0.25 * bins), 1, 0)\\n \\n # Prioritize bins with more than 75% free capacity\\n bonus = np.where(available_capacity > (0.75 * bins), 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Penalizing bins with more than 20% excessive capacity and rewarding bins with more than 80% of their capacity, considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of capacity used by each bin\\n capacity_used = (bins - excess_capacity) / bins\\n \\n # Reward bins with more than 80% capacity used\\n rewards = np.where(capacity_used > 0.8, 1, 0)\\n \\n # Penalize bins with more than 20% excess capacity\\n penalties = np.where(excess_capacity > 0.2 * bins, -1, 0)\\n \\n # Combine rewards and penalties to get the final score\\n scores = rewards + penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: item size, bin capacity. New algorithm: For each bin, calculate its score as the difference between its rest capacity and the item size, if positive, the score is 0, otherwise, the score is the inverse of the difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the rest capacity and the item size\\n diff = bins - item\\n \\n # Set the score to 0 if the difference is positive, otherwise set it to the inverse of the difference\\n scores = np.where(diff > 0, 0, 1 / diff)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a very high score to bins that exactly fit the item's size, while for all other less-fitting bins, calculate scores based on the difference in capacities and item size, with a penalty for bins exceeding the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin sizes\\n diff = np.abs(item - bins)\\n \\n # Calculate the penalty for bins that exceed the item size\\n penalty = np.maximum(0, diff - item)\\n \\n # Calculate the score for each bin\\n scores = np.where(diff == 0, np.inf, 1 / (1 + penalty))\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizing bins with less than 20% free capacity and penalizing bins that have more than 30% of the item's capacity while decreasing the penalty term to zero for bins with less than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that have more than 30% of the item's capacity\\n penalty = np.where(free_capacity > 0.3 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 40% free capacity\\n penalty = np.where(free_capacity < 0.4 * bins, 0, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm for minimizing the number of used bins: Prioritize bins that can fit the item leaving less than 20% free capacity, and penalize bins that leave more than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 20% free capacity\\n priority_bins = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 40% free capacity\\n penalty_bins = np.where(free_capacity > 0.4 * bins, 1, 0)\\n \\n # Combine the prioritization and penalization scores\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 25% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.25 * bins, 1 + (0.25 - free_capacity / bins), 0)\\n scores = np.where(free_capacity > 0.75 * bins, 1 - (free_capacity - 0.75 * bins) / bins, scores)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Penalize bins with more than 20% excessive capacity and reward bins with more than 65% of their capacity, considering the item's size and the average capacity utilization of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Penalize bins with more than 20% excess capacity\\n penalized_bins = np.where(percent_excess > 20, 0, 1)\\n \\n # Reward bins with more than 65% of their capacity\\n rewarded_bins = np.where(percent_excess > 65, 1, 0)\\n \\n # Combine the penalties and rewards\\n scores = penalized_bins + rewarded_bins\\n \\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalizing bins with more than 15% excessive capacity and rewarding bins with more than 75% of their capacity, considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Reward bins with more than 75% of their capacity\\n rewards = np.where(percent_excess > 75, 1, 0)\\n \\n # Penalize bins with more than 15% excess capacity\\n penalties = np.where(percent_excess > 15, -1, 0)\\n \\n # Combine rewards and penalties to get the final score\\n scores = rewards + penalties\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins that can fit the item leaving less than 30% free capacity, penalized bins that have more than 30% free capacity, and assign a small bonus to bins that leave less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 30% free capacity\\n penalty = np.where(free_capacity > (bins * 0.3), 0, (bins * 0.3) - free_capacity)\\n \\n # Bonus for bins with less than 10% free capacity\\n bonus = np.where(free_capacity < (bins * 0.1), (bins * 0.1) - free_capacity, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a variable amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold based on the difference\\n fav_thresh = np.minimum(diff / (item + 1), 0.5)\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 - fav_thresh[i]\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 20% free capacity, and penalize bins with more than 60% of their capacity to prefer smaller capacity bins rather than larger ones.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of their capacity\\n penalty = np.where(free_capacity > 0.6 * bins, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.1 * bins, 10 * (1 - free_capacity / bins), 0)\\n scores += np.where(free_capacity > 0.5 * bins, -5 * (free_capacity / bins - 0.5), 0)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.1 * bins, 10 * (1 - free_capacity / bins), 0)\\n scores += np.where(free_capacity > 0.9 * bins, -10 * (free_capacity / bins - 0.9), 0)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin as the natural log of the non-positive difference between the bin's rest capacity and item size, and the rest capacity to the power of the positive difference\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.log(np.abs(bins - item)) + (bins / (bins - item)) ** 2\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the exponential of the negative difference between the ratio of bin's rest capacity and item size, and the natural logarithm of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.exp(-np.log(bins / item))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, calculate its ratio of rest capacity to item size; if greater than 1, the score is 0, otherwise, the score is the inverse of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = (bins - item) / item\\n \\n # Set the score for each bin based on the ratio\\n scores = np.where(ratios > 1, 0, 1 / ratios)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a fixed amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold for each bin\\n thresholds = np.maximum(0, diff - 1)\\n \\n # Calculate the scores for each bin\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 / (thresholds[i] + 1)\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritizing bins that have more than 75% of their capacity and penalizing bins that have less than 25% free capacity \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Penalize bins with less than 25% free capacity\\n penalty = np.where(available_capacity < (0.25 * bins), 1, 0)\\n \\n # Prioritize bins with more than 75% free capacity\\n bonus = np.where(available_capacity > (0.75 * bins), 1, 0)\\n \\n # Combine the penalty and bonus to get the final score\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Main steps: Penalize bins with more than 30% of the item's capacity while increasing the penalty term; prioritize bins with less than 5% free capacity and decrease the priority term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum capacity of the bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the remaining capacity of the bins\\n remaining_capacity = bins - item\\n \\n # Calculate the percentage of the item's capacity used by each bin\\n usage_percentage = (remaining_capacity / max_capacity) * 100\\n \\n # Calculate the penalty term based on the usage percentage\\n penalty_term = np.where(usage_percentage > 30, 100 - usage_percentage, 0)\\n \\n # Calculate the priority term based on the remaining capacity\\n priority_term = np.where(remaining_capacity < 5, 100 - remaining_capacity, 0)\\n \\n # Combine the penalty and priority terms to get the final score\\n scores = penalty_term + priority_term\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm to prioritize bins that have less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while increasing the penalty term .\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of free capacity for each bin\\n free_capacity = (bins - item) / bins\\n \\n # Penalize bins with more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4, 1, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1, 1, 0)\\n \\n # Combine the penalty and priority scores\\n scores = penalty + priority\\n \\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that can fit the item leaving less than 10% free capacity, and penalize bins that leave more than 30% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 10% free capacity\\n priority_bins = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 30% free capacity\\n penalty_bins = np.where(free_capacity > 0.3 * bins, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 40% of the item's capacity while decreasing the penalty term.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 10% free capacity\\n priority = np.where(free_capacity < 0.1 * bins, 1, 0)\\n \\n # Penalize bins that have more than 40% of the item's capacity\\n penalty = np.where(free_capacity > 0.4 * item, 1, 0)\\n \\n # Decrease the penalty term for bins with less than 50% free capacity\\n penalty = np.where(free_capacity < 0.5 * bins, 0.5 * penalty, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have more than 50% of their capacity and giving a larger penalty to bins that have less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the available capacity for each bin\\n available_capacity = bins - item\\n \\n # Prioritize bins with more than 50% capacity\\n priority_mask = (available_capacity > bins * 0.5)\\n priority_score = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins with less than 10% free capacity\\n penalization_mask = (available_capacity < bins * 0.1)\\n penalization_score = np.where(penalization_mask, 1, 0)\\n \\n # Combine the priority and penalization scores\\n scores = priority_score + penalization_score\\n \\n return scores\",\n \"objective\": 0.02193,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign priority to bins with close capacity to the size of the item, while penalizing bins with smaller capacities and omitting those with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Penalize bins with smaller capacities\\n penalty = np.where(diff < 0.5 * item, 0.5 * diff, 0)\\n \\n # Calculate the score for each bin\\n scores = np.exp(-penalty / (0.5 * item))\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity, but only if the bin's capacity exceeds twice the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n # Normalize the scores to ensure they are between 0 and 1\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03441,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins that have less than 20% free capacity and penalizing bins that have more than 60% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of the item's capacity\\n penalty = np.where(free_capacity > 0.6 * item, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizing bins with less than 20% free capacity and penalizing bins that have more than 30% of the item's capacity while decreasing the penalty term to zero for bins with less than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that have more than 30% of the item's capacity\\n penalty = np.where(free_capacity > 0.3 * item, 1, 0)\\n \\n # Decrease the penalty term to zero for bins with less than 40% free capacity\\n penalty = np.where(free_capacity < 0.4 * bins, 0, penalty)\\n \\n # Calculate the final score for each bin\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm for minimizing the number of used bins: Prioritize bins that can fit the item leaving less than 20% free capacity, and penalize bins that leave more than 40% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 20% free capacity\\n priority_bins = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins that leave more than 40% free capacity\\n penalty_bins = np.where(free_capacity > 0.4 * bins, 1, 0)\\n \\n # Combine the prioritization and penalization scores\\n scores = priority_bins + penalty_bins\\n \\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that can fit the item leaving less than 20% free capacity, and penalizing bins that leave more than 40% free capacity based on the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Prioritize bins that can fit the item leaving less than 20% free capacity\\n priority_mask = (free_capacity < 0.2 * bins) & (free_capacity >= 0)\\n priority_scores = np.where(priority_mask, 1, 0)\\n \\n # Penalize bins that leave more than 40% free capacity based on the item size\\n penalty_mask = (free_capacity > 0.4 * bins) & (free_capacity <= 0.6 * bins)\\n penalty_scores = np.where(penalty_mask, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority_scores + penalty_scores\\n \\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 25% free capacity and penalizing bins that have more than 75% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.25 * bins, 1 + (0.25 - free_capacity / bins), 0)\\n scores = np.where(free_capacity > 0.75 * bins, 1 - (free_capacity - 0.75 * bins) / bins, scores)\\n \\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Penalize bins with more than 20% excessive capacity and reward bins with more than 65% of their capacity, considering the item's size and the average capacity utilization of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Penalize bins with more than 20% excess capacity\\n penalized_bins = np.where(percent_excess > 20, 0, 1)\\n \\n # Reward bins with more than 65% of their capacity\\n rewarded_bins = np.where(percent_excess > 65, 1, 0)\\n \\n # Combine the penalties and rewards\\n scores = penalized_bins + rewarded_bins\\n \\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalizing bins with more than 15% excessive capacity and rewarding bins with more than 75% of their capacity, considering the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the excess capacity of each bin\\n excess_capacity = bins - item\\n \\n # Calculate the percentage of excess capacity for each bin\\n percent_excess = excess_capacity / bins * 100\\n \\n # Reward bins with more than 75% of their capacity\\n rewards = np.where(percent_excess > 75, 1, 0)\\n \\n # Penalize bins with more than 15% excess capacity\\n penalties = np.where(percent_excess > 15, -1, 0)\\n \\n # Combine rewards and penalties to get the final score\\n scores = rewards + penalties\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Prioritize bins that can fit the item leaving less than 30% free capacity, penalized bins that have more than 30% free capacity, and assign a small bonus to bins that leave less than 10% free capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = bins - item\\n \\n # Penalize bins with more than 30% free capacity\\n penalty = np.where(free_capacity > (bins * 0.3), 0, (bins * 0.3) - free_capacity)\\n \\n # Bonus for bins with less than 10% free capacity\\n bonus = np.where(free_capacity < (bins * 0.1), (bins * 0.1) - free_capacity, 0)\\n \\n # Calculate the total score for each bin\\n scores = penalty + bonus\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Reduce the favoring threshold for bins with capacities closely matching the item size by a variable amount.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the bin capacities\\n diff = np.abs(item - bins)\\n \\n # Calculate the favoring threshold based on the difference\\n fav_thresh = np.minimum(diff / (item + 1), 0.5)\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = 1 - fav_thresh[i]\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 15% free capacity and penalizing bins that have more than 85% of the item's capacity. The penalty is higher if the bin's free capacity is greater than 25%.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the percentage of free capacity for each bin\\n percent_free = (free_capacity / bins) * 100\\n \\n # Penalize bins with more than 85% free capacity\\n penalized_bins = np.where(percent_free > 85, 1, 0)\\n \\n # Calculate the penalty for each bin based on its free capacity\\n penalty = np.where(penalized_bins == 1, 100 - percent_free, 0)\\n \\n # Calculate the score for each bin\\n scores = np.where(penalized_bins == 1, penalty, 0) + np.where(percent_free < 15, 100 - percent_free, 0)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with less than 20% free capacity, and penalize bins with more than 60% of their capacity to prefer smaller capacity bins rather than larger ones.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with less than 20% free capacity\\n priority = np.where(free_capacity < 0.2 * bins, 1, 0)\\n \\n # Penalize bins with more than 60% of their capacity\\n penalty = np.where(free_capacity > 0.6 * bins, 1, 0)\\n \\n # Calculate the score for each bin\\n scores = (priority + penalty) / (1 + penalty)\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with less than 10% free capacity and penalizing bins that have more than 50% of the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(0, bins - item)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.1 * bins, 10 * (1 - free_capacity / bins), 0)\\n scores += np.where(free_capacity > 0.5 * bins, -5 * (free_capacity / bins - 0.5), 0)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins that have less than 10% free capacity and penalizing bins that have more than 90% of the item's capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the free capacity of each bin\\n free_capacity = np.maximum(bins - item, 0)\\n \\n # Calculate the score for each bin based on its free capacity\\n scores = np.where(free_capacity < 0.1 * bins, 10 * (1 - free_capacity / bins), 0)\\n scores += np.where(free_capacity > 0.9 * bins, -10 * (free_capacity / bins - 0.9), 0)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The algorithm calculates the scores for each bin based on the exponential decay of their rest capacities, ensuring optimal bin selection and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the exponential decay of their rest capacities\\n scores = np.exp(-bins / (item + 1))\\n \\n # Ensure that the scores are normalized to sum up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm 6: Score each bin by subtracting the squared difference between the bin's rest capacity and half of the bin's maximum capacity from the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the squared difference between the bin's rest capacity and half of the bin's maximum capacity\\n diff = (bins - item) ** 2\\n \\n # Subtract the squared difference from the bin's maximum capacity\\n scores = bins - diff\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates scores inversely proportional to the rest capacities of bins, prioritizing bins with higher remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacities of the bins\\n inv_rest_capacities = 1 / (bins - item)\\n \\n # Prioritize bins with higher remaining capacity\\n scores = np.argsort(inv_rest_capacities)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will prioritize bins with higher rest capacity and lower index, while penalizing bins with maximum capacity and fullness level to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the fullness level of each bin\\n fullness_level = (rest_capacity / bins) * 100\\n \\n # Prioritize bins with higher rest capacity and lower index\\n priority = np.argsort(-rest_capacity) + np.argsort(fullness_level)\\n \\n # Penalize bins with maximum capacity and fullness level\\n penalty = np.where(np.logical_and(rest_capacity == bins, fullness_level == 100), 100, 0)\\n \\n # Calculate the final score for each bin\\n scores = priority - penalty\\n \\n return scores\",\n \"objective\": 0.06721,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will prioritize bins with higher rest capacity, lower index, and a penalty for bins with maximum capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with higher rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize bins with maximum capacity\\n penalty = np.where(bins == bins.max(), 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.07023,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using a scoring function that prioritizes bins with smaller rest capacity and closer item size using exponential decay instead of linear decay: scores = np.maximum(bins - item, 0) / (1 + (np.arange(len(bins)) ** 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate scores using a scoring function that prioritizes bins with smaller rest capacity and closer item size using exponential decay instead of linear decay\\n scores = np.maximum(bins - item, 0) / (1 + (np.arange(len(bins)) ** 2))\\n return scores\",\n \"objective\": 0.07375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the ratio of the bin's remaining capacity to the maximum capacity and the bin's index, and multiply the result by a weight that is inversely proportional to the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the bin's remaining capacity to its maximum capacity\\n ratios = (bins - item) / bins\\n \\n # Multiply the ratio by a weight that is inversely proportional to the bin's index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = ratios * weights\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm that calculates the bin score by taking the product of the remaining capacity and item size, and adding a penalty for bins that have been used less.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the score for each bin based on the product of the remaining capacity and item size\\n scores = remaining_capacity * item\\n \\n # Add a penalty for bins that have been used less\\n scores -= (bins - item) ** 2\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.09035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel algorithm that calculates the bin score by taking the difference between the remaining capacity and the difference between the maximum capacity and the item size, then multiplying the result by a weight that is inversely proportional to the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the remaining capacity and the difference between the maximum capacity and the item size\\n diff = np.abs(bins - item)\\n \\n # Multiply the result by a weight that is inversely proportional to the bin's index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = diff * weights\\n \\n return scores\",\n \"objective\": 0.10746,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the product of the total capacity and the used capacity, and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the total capacity and the used capacity for each bin\\n prod_total_used = bins * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / prod_total_used\\n \\n # Subtract a random factor proportional to the remaining capacity from the score\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - scores)\\n \\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity, penalize larger bins by a factor proportional to the item's size relative to bin capacity, and introduce a random factor to encourage diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for larger bins\\n penalty = np.maximum(0, (item - bins) / bins)\\n \\n # Calculate the random factor\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the three factors\\n scores = inv_rest_capacity + penalty + random_factor\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying the inverse rest capacity by the item's size and then adding a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the inverse rest capacity\\n random_component = np.random.uniform(size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the bin index, introducing randomness, and then taking the logarithm of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.rand(len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Take the logarithm of the scores\\n scores = np.log(scores)\\n \\n return scores\",\n \"objective\": 0.02767,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding a random number between 0 and 1 to the sum of the inverse rest capacity with the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the sum of the inverse rest capacity\\n # and the bin's capacity\\n scores = inv_rest_capacity + np.random.uniform(size=len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm introduces a configurable parameter alpha that balances between prioritizing remaining capacity (alpha < 1) and randomness (alpha > 1) in the score function: score = (1 - alpha) * inv_rest_capacity + alpha * rand_factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, alpha=0.5):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin using the formula provided\\n scores = (1 - alpha) * inv_rest_capacity + alpha * rand_factor\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.rand(len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting inverse rest capacity from total capacity, and introducing randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to enhance utilization\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea of the provided algorithms is to combine the inverse rest capacity with a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin. The new algorithm uses a score function that combines a random factor with the number of bins to divide the inverse rest capacity and then adds a constant value to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to prioritize bins with higher remaining capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Divide by the number of bins to normalize the scores\\n scores = inv_rest_capacity / len(bins)\\n \\n # Add a constant value to the scores to ensure that all bins are considered\\n scores += 1\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 0.5, size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the product of the total capacity and the used capacity, and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the total capacity and the used capacity for each bin\\n prod_total_used = bins * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / prod_total_used\\n \\n # Subtract a random factor proportional to the remaining capacity from the score\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - scores)\\n \\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity, penalize larger bins by a factor proportional to the item's size relative to bin capacity, and introduce a random factor to encourage diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for larger bins\\n penalty = np.maximum(0, (item - bins) / bins)\\n \\n # Calculate the random factor\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the three factors\\n scores = inv_rest_capacity + penalty + random_factor\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying the inverse rest capacity by the item's size and then adding a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the inverse rest capacity\\n random_component = np.random.uniform(size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the bin index, introducing randomness, and then taking the logarithm of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.rand(len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Take the logarithm of the scores\\n scores = np.log(scores)\\n \\n return scores\",\n \"objective\": 0.02767,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to combine the inverse rest capacity with a random factor to create a score for each bin. The new algorithm will prioritize bins with larger inverse rest capacity and add randomness to prevent always choosing the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + random_factor\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding a random number between 0 and 1 to the sum of the inverse rest capacity with the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the sum of the inverse rest capacity\\n # and the bin's capacity\\n scores = inv_rest_capacity + np.random.uniform(size=len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm introduces a configurable parameter alpha that balances between prioritizing remaining capacity (alpha < 1) and randomness (alpha > 1) in the score function: score = (1 - alpha) * inv_rest_capacity + alpha * rand_factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, alpha=0.5):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin using the formula provided\\n scores = (1 - alpha) * inv_rest_capacity + alpha * rand_factor\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.rand(len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the product of the total capacity and the used capacity, and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the total capacity and the used capacity for each bin\\n prod_total_used = bins * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / prod_total_used\\n \\n # Subtract a random factor proportional to the remaining capacity from the score\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - scores)\\n \\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity, penalize larger bins by a factor proportional to the item's size relative to bin capacity, and introduce a random factor to encourage diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for larger bins\\n penalty = np.maximum(0, (item - bins) / bins)\\n \\n # Calculate the random factor\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the three factors\\n scores = inv_rest_capacity + penalty + random_factor\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying the inverse rest capacity by the item's size and then adding a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the inverse rest capacity\\n random_component = np.random.uniform(size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the bin index, introducing randomness, and then taking the logarithm of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.rand(len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Take the logarithm of the scores\\n scores = np.log(scores)\\n \\n return scores\",\n \"objective\": 0.02767,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to combine the inverse rest capacity with a random factor to create a score for each bin. The new algorithm will prioritize bins with larger inverse rest capacity and add randomness to prevent always choosing the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + random_factor\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding a random number between 0 and 1 to the sum of the inverse rest capacity with the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the sum of the inverse rest capacity\\n # and the bin's capacity\\n scores = inv_rest_capacity + np.random.uniform(size=len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm introduces a configurable parameter alpha that balances between prioritizing remaining capacity (alpha < 1) and randomness (alpha > 1) in the score function: score = (1 - alpha) * inv_rest_capacity + alpha * rand_factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, alpha=0.5):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin using the formula provided\\n scores = (1 - alpha) * inv_rest_capacity + alpha * rand_factor\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a difference between inverse rest capacity weighted by the item weight and inverse minimum capacity weighted by the bin weight, with a randomness factor that is dependent on the item relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity weighted by the item weight\\n inv_rest_capacity = 1 / (bins - item)\\n inv_min_capacity = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_min_capacity\\n \\n # Add a randomness factor to the scores\\n randomness = np.random.randint(0, 100, size=len(bins))\\n scores += randomness\\n \\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the product of the total capacity and the used capacity, and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the total capacity and the used capacity for each bin\\n prod_total_used = bins * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / prod_total_used\\n \\n # Subtract a random factor proportional to the remaining capacity from the score\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - scores)\\n \\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by penalized inv_rest_capacity subtracted by the squared inv_rest_capacity multiplied by a random factor dependent on the item's distance to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for each bin based on the item's distance to the bin\\n penalty = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity - penalty\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by multiplying the square root of the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = np.sqrt(inv_rest_capacity * max_bin_capacity) - np.random.randint(0, item, size=len(bins))\\n \\n return scores\",\n \"objective\": 0.02304,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins based on a function of their inverse rest capacity, penalizing occupied bins, and adding a random factor proportional to the item's relative size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins == 0, 0, 1e9)\\n \\n # Add a random factor proportional to the item's relative size\\n rand_factor = np.random.randint(1, 10, size=len(bins)) * item\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity, penalize larger bins by a factor proportional to the item's size relative to bin capacity, and introduce a random factor to encourage diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for larger bins\\n penalty = np.maximum(0, (item - bins) / bins)\\n \\n # Calculate the random factor\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the three factors\\n scores = inv_rest_capacity + penalty + random_factor\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying the inverse rest capacity by the item's size and then adding a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the inverse rest capacity\\n random_component = np.random.uniform(size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the bin index, introducing randomness, and then taking the logarithm of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.rand(len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Take the logarithm of the scores\\n scores = np.log(scores)\\n \\n return scores\",\n \"objective\": 0.02767,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a difference between inverse rest capacity weighted by the item weight and inverse minimum capacity weighted by the bin weight, with a randomness factor that is dependent on the item relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity weighted by the item weight\\n inv_rest_capacity = 1 / (bins - item)\\n inv_min_capacity = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_min_capacity\\n \\n # Add a randomness factor to the scores\\n randomness = np.random.randint(0, 100, size=len(bins))\\n scores += randomness\\n \\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the product of the total capacity and the used capacity, and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the product of the total capacity and the used capacity for each bin\\n prod_total_used = bins * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / prod_total_used\\n \\n # Subtract a random factor proportional to the remaining capacity from the score\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - scores)\\n \\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by penalized inv_rest_capacity subtracted by the squared inv_rest_capacity multiplied by a random factor dependent on the item's distance to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for each bin based on the item's distance to the bin\\n penalty = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity - penalty\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by multiplying the square root of the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = np.sqrt(inv_rest_capacity * max_bin_capacity) - np.random.randint(0, item, size=len(bins))\\n \\n return scores\",\n \"objective\": 0.02304,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins based on a function of their inverse rest capacity, penalizing occupied bins, and adding a random factor proportional to the item's relative size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins == 0, 0, 1e9)\\n \\n # Add a random factor proportional to the item's relative size\\n rand_factor = np.random.randint(1, 10, size=len(bins)) * item\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity, penalize larger bins by a factor proportional to the item's size relative to bin capacity, and introduce a random factor to encourage diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for larger bins\\n penalty = np.maximum(0, (item - bins) / bins)\\n \\n # Calculate the random factor\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the three factors\\n scores = inv_rest_capacity + penalty + random_factor\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying the inverse rest capacity by the item's size and then adding a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the inverse rest capacity\\n random_component = np.random.uniform(size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by adding randomness to the difference between a random number between 0 and 1 and the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the difference between a random number between 0 and 1 and the inverse rest capacity\\n randomness = np.random.uniform(size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02727,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a difference between inverse rest capacity weighted by the item weight and inverse minimum capacity weighted by the bin weight, with a randomness factor that is dependent on the item relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity weighted by the item weight\\n inv_rest_capacity = 1 / (bins - item)\\n inv_min_capacity = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_min_capacity\\n \\n # Add a randomness factor to the scores\\n randomness = np.random.randint(0, 100, size=len(bins))\\n scores += randomness\\n \\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weighted sum of inverse rest capacity, occupancy status, and random factor\\n scores = inv_rest_capacity * occupancy_status + random_factor\\n \\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the inverse maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum bin capacity\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_bin_capacity = 1 / bins.max()\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n scores -= np.random.randint(0, 100, size=len(bins)) * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by penalized inv_rest_capacity subtracted by the squared inv_rest_capacity multiplied by a random factor dependent on the item's distance to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for each bin based on the item's distance to the bin\\n penalty = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity - penalty\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function prioritizing bins by inverse rest capacity with a randomness factor adjusted based on the difference between the item and bin sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor to the scores\\n randomness = np.random.randint(0, 100, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02214,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by multiplying the square root of the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = np.sqrt(inv_rest_capacity * max_bin_capacity) - np.random.randint(0, item, size=len(bins))\\n \\n return scores\",\n \"objective\": 0.02304,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritizing bins based on a function of their inverse rest capacity, penalizing occupied bins, and adding a random factor proportional to the item's relative size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins == 0, 0, 1e9)\\n \\n # Add a random factor proportional to the item's relative size\\n rand_factor = np.random.randint(1, 10, size=len(bins)) * item\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the inverse rest capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and compensate for small item sizes relative to bin maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n occupied_penalty = np.where(bins == 0, 0, 1e9)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n small_item_compensation = np.where(item < 0.5 * bins, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + occupied_penalty + small_item_compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a difference between inverse rest capacity weighted by the item weight and inverse minimum capacity weighted by the bin weight, with a randomness factor that is dependent on the item relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity weighted by the item weight\\n inv_rest_capacity = 1 / (bins - item)\\n inv_min_capacity = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_min_capacity\\n \\n # Add a randomness factor to the scores\\n randomness = np.random.randint(0, 100, size=len(bins))\\n scores += randomness\\n \\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the inverse maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum bin capacity\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_bin_capacity = 1 / bins.max()\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n scores -= np.random.randint(0, 100, size=len(bins)) * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on the bin's size relative to the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness factors\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the difference between the item's features and the bin's features.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + rand_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by penalized inv_rest_capacity subtracted by the squared inv_rest_capacity multiplied by a random factor dependent on the item's distance to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for each bin based on the item's distance to the bin\\n penalty = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity - penalty\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness factors\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a difference between inverse rest capacity weighted by the item weight and inverse minimum capacity weighted by the bin weight, with a randomness factor that is dependent on the item relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity weighted by the item weight\\n inv_rest_capacity = 1 / (bins - item)\\n inv_min_capacity = 1 / bins\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_min_capacity\\n \\n # Add a randomness factor to the scores\\n randomness = np.random.randint(0, 100, size=len(bins))\\n scores += randomness\\n \\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Prioritizes bins based on their inverse rest capacity, penalizes occupied bins, and compensates for small item sizes relative to bin maximum capacities differently.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n occupied_penalty = 100 * (bins == 0)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n small_item_compensation = 0.5 * (item < 0.5 * bins)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + occupied_penalty + small_item_compensation\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the inverse maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum bin capacity\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_bin_capacity = 1 / bins.max()\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n scores -= np.random.randint(0, 100, size=len(bins)) * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on the bin's size relative to the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness factors\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the difference between the item's features and the bin's features.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + rand_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by penalized inv_rest_capacity subtracted by the squared inv_rest_capacity multiplied by a random factor dependent on the item's distance to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for each bin based on the item's distance to the bin\\n penalty = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity - penalty\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Prioritizes bins based on their inverse rest capacity, penalizes occupied bins, and compensates for small item sizes relative to bin maximum capacities differently.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n occupied_penalty = 100 * (bins == 0)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n small_item_compensation = 0.5 * (item < 0.5 * bins)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + occupied_penalty + small_item_compensation\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the inverse rest capacity by a function of the item size and the maximum capacity, then add a randomized term that is dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the final score\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the inverse maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum bin capacity\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_bin_capacity = 1 / bins.max()\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n scores -= np.random.randint(0, 100, size=len(bins)) * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on the bin's size relative to the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness factors\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor inversely proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, inv_rest_capacity - 1)\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by score, which includes the inverse rest capacity and a randomness that is dependent on a feature of the item relative to the bin, and increase the impact of the randomness using an exponential function\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness component for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness components\\n scores = inv_rest_capacity + randomness\\n \\n # Exponential function to amplify the effect of the randomness component\\n scores = np.exp(scores)\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins inversely proportional to their available capacity, penalizes occupied bins, and accommodates small items through a constant relative to bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity for each bin\\n inv_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a constant value\\n penalty = np.where(bins > 0, 1, 0) * 10\\n \\n # Accommodate small items by adding a constant relative to bin size\\n small_item_bonus = np.where(item < 0.5 * bins, 1, 0) * 0.5\\n \\n # Calculate the final score for each bin\\n scores = inv_capacity + penalty + small_item_bonus\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the inverse rest capacity by a function of the item size and the maximum capacity, then add a randomized term that is dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the final score\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the inverse maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum bin capacity\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_bin_capacity = 1 / bins.max()\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n scores -= np.random.randint(0, 100, size=len(bins)) * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on the bin's size relative to the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness factors\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor inversely proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, inv_rest_capacity - 1)\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item. Then, multiply the scores by a weight that is inversely proportional to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.minimum(bins, item) * (1 / bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm 6: Score each bin by subtracting the squared difference between the bin's rest capacity and half of the bin's maximum capacity from the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the squared difference between the bin's rest capacity and half of the bin's maximum capacity\\n diff = (bins - item) ** 2\\n \\n # Subtract the squared difference from the bin's maximum capacity\\n scores = bins - diff\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates scores inversely proportional to the rest capacities of bins, prioritizing bins with higher remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacities of the bins\\n inv_rest_capacities = 1 / (bins - item)\\n \\n # Prioritize bins with higher remaining capacity\\n scores = np.argsort(inv_rest_capacities)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores based on a weighted combination of the normalized available capacity and the inverse of the bin index, prioritizing bins with higher normalized capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the available capacity of each bin\\n norm_capacity = bins / np.max(bins)\\n \\n # Calculate the inverse of the bin index\\n inv_index = 1 / (np.arange(len(bins)) + 1)\\n \\n # Weighted combination of normalized available capacity and inverse of bin index\\n scores = norm_capacity * inv_index\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with low fullness level, then high remaining capacity. Penalize bins with high fullness level, then zero remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the fullness level of each bin\\n fullness = (bins - item) / bins\\n \\n # Prioritize bins with low fullness level\\n priority_score = 1 - fullness\\n \\n # Penalize bins with high fullness level\\n penalty_score = fullness ** 2\\n \\n # Combine the priority and penalty scores\\n scores = priority_score + penalty_score\\n \\n # Normalize the scores to ensure they are between 0 and 1\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function prioritizes bins with higher remaining capacity and lower fullness level, while penalizing bins with maximum capacity and high fullness level to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity and fullness level for each bin\\n remaining_capacity = bins - item\\n fullness_level = (bins - remaining_capacity) / bins\\n \\n # Prioritize bins with higher remaining capacity and lower fullness level\\n priority = np.where(remaining_capacity > 0, remaining_capacity, 0) + \\\\\\n np.where(fullness_level < 1, 1 - fullness_level, 0)\\n \\n # Penalize bins with maximum capacity and high fullness level\\n penalty = np.where(bins == max(bins), 1, 0) + \\\\\\n np.where(fullness_level >= 0.5, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.05544,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity and bin index, prioritizing bins with higher rest capacity and assigning a reasonable penalty for bins with a high index to encourage using fewer bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on a combination of rest capacity and bin index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (i + 1)\\n else:\\n scores[i] = 0\\n \\n # Penalize bins with high indices to encourage using fewer bins\\n penalties = np.arange(len(bins)) ** 2\\n scores -= penalties\\n \\n return scores\",\n \"objective\": 0.06027,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with smaller index and lower fullness level, penalizing bins with higher fullness level and maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the fullness level of each bin\\n fullness = (bins - item) / bins\\n \\n # Penalize bins with high fullness levels\\n penalty = np.maximum(0, fullness - 0.5) ** 2\\n \\n # Prioritize bins with smaller indices and lower fullness levels\\n priority = np.minimum(fullness, 0.5) + np.arange(len(bins)) * 0.1\\n \\n # Calculate the score for each bin\\n scores = priority - penalty\\n \\n return scores\",\n \"objective\": 0.06329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will prioritize bins with higher rest capacity and lower index, while penalizing bins with maximum capacity and fullness level to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the fullness level of each bin\\n fullness_level = (rest_capacity / bins) * 100\\n \\n # Prioritize bins with higher rest capacity and lower index\\n priority = np.argsort(-rest_capacity) + np.argsort(fullness_level)\\n \\n # Penalize bins with maximum capacity and fullness level\\n penalty = np.where(np.logical_and(rest_capacity == bins, fullness_level == 100), 100, 0)\\n \\n # Calculate the final score for each bin\\n scores = priority - penalty\\n \\n return scores\",\n \"objective\": 0.06721,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will prioritize bins with higher rest capacity, lower index, and a penalty for bins with maximum capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = np.maximum(0, bins - item)\\n \\n # Prioritize bins with higher rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize bins with maximum capacity\\n penalty = np.where(bins == bins.max(), 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.07023,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using a scoring function that prioritizes bins with smaller rest capacity and closer item size using exponential decay instead of linear decay: scores = np.maximum(bins - item, 0) / (1 + (np.arange(len(bins)) ** 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate scores using a scoring function that prioritizes bins with smaller rest capacity and closer item size using exponential decay instead of linear decay\\n scores = np.maximum(bins - item, 0) / (1 + (np.arange(len(bins)) ** 2))\\n return scores\",\n \"objective\": 0.07375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the ratio of the bin's remaining capacity to the maximum capacity and the bin's index, and multiply the result by a weight that is inversely proportional to the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the bin's remaining capacity to its maximum capacity\\n ratios = (bins - item) / bins\\n \\n # Multiply the ratio by a weight that is inversely proportional to the bin's index\\n weights = 1 / (np.arange(len(bins)) + 1)\\n scores = ratios * weights\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a logarithm of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=inv_rest_capacity.shape)\\n inv_rest_capacity += rand_term\\n \\n # Take the logarithm of the sum of both terms\\n scores = np.log(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins inversely proportional to their available capacity, penalizes occupied bins, and accommodates small items through a constant relative to bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity for each bin\\n inv_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a constant value\\n penalty = np.where(bins > 0, 1, 0) * 10\\n \\n # Accommodate small items by adding a constant relative to bin size\\n small_item_bonus = np.where(item < 0.5 * bins, 1, 0) * 0.5\\n \\n # Calculate the final score for each bin\\n scores = inv_capacity + penalty + small_item_bonus\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the inverse rest capacity by a function of the item size and the maximum capacity, then add a randomized term that is dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the final score\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the inverse maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum bin capacity\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_bin_capacity = 1 / bins.max()\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * inv_max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n scores -= np.random.randint(0, 100, size=len(bins)) * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on the bin's size relative to the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the inverse rest capacity and randomness factors\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor inversely proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, inv_rest_capacity - 1)\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a sine of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Take the sine of the sum of both terms\\n scores = np.sin(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum additive of the inverse rest capacity and the subtracted a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, item, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a logarithm of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=inv_rest_capacity.shape)\\n inv_rest_capacity += rand_term\\n \\n # Take the logarithm of the sum of both terms\\n scores = np.log(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins inversely proportional to their available capacity, penalizes occupied bins, and accommodates small items through a constant relative to bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity for each bin\\n inv_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a constant value\\n penalty = np.where(bins > 0, 1, 0) * 10\\n \\n # Accommodate small items by adding a constant relative to bin size\\n small_item_bonus = np.where(item < 0.5 * bins, 1, 0) * 0.5\\n \\n # Calculate the final score for each bin\\n scores = inv_capacity + penalty + small_item_bonus\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the inverse rest capacity by a function of the item size and the maximum capacity, then add a randomized term that is dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the final score\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on the minimum of the inverse of the rest capacity minus a random factor proportional to the item size and the maximum bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity - rand_factor * item\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a sine of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Take the sine of the sum of both terms\\n scores = np.sin(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum additive of the inverse rest capacity and the subtracted a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, item, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a score that is a product of the inverse rest capacity and the inverse of the maximum capacity of the bin, then add a random term that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_capacity = 1 / bins\\n \\n # Calculate the random term\\n rand_term = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * inv_max_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a logarithm of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=inv_rest_capacity.shape)\\n inv_rest_capacity += rand_term\\n \\n # Take the logarithm of the sum of both terms\\n scores = np.log(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins inversely proportional to their available capacity, penalizes occupied bins, and accommodates small items through a constant relative to bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity for each bin\\n inv_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a constant value\\n penalty = np.where(bins > 0, 1, 0) * 10\\n \\n # Accommodate small items by adding a constant relative to bin size\\n small_item_bonus = np.where(item < 0.5 * bins, 1, 0) * 0.5\\n \\n # Calculate the final score for each bin\\n scores = inv_capacity + penalty + small_item_bonus\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the inverse rest capacity by a function of the item size and the maximum capacity, then add a randomized term that is dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the final score\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the highest score calculated by the ratio of bin capacity minus item size to the square of their difference, minus a random factor proportional to the item size if the rest capacity is smaller than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (bin - item) ** 2\\n else:\\n scores[i] = 0\\n \\n # Add a random factor to the scores\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores += rand_factor * (item - bin)\\n \\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a weighted sum of inverse rest capacity, occupancy status, and a random factor proportional to the item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the occupancy status for each bin\\n occupancy_status = np.where(bins > item, 1, 0)\\n \\n # Calculate the random factor for each bin\\n random_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Weight the factors using the learned weights\\n weights = np.array([0.5, 0.3, 0.2])\\n weighted_factors = np.dot(weights, np.array([inv_rest_capacity, occupancy_status, random_factor]))\\n \\n # Normalize the weighted factors to get the scores\\n scores = weighted_factors / np.sum(weighted_factors)\\n \\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a sine of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Take the sine of the sum of both terms\\n scores = np.sin(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum difference between the inverse rest capacity multiplied by the item size and the subtracted random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity multiplied by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the subtracted random term dependent on both the item size and the remaining capacity\\n rand_term = np.random.randint(0, item, size=len(bins)) * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * rand_term\\n \\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum additive of the inverse rest capacity and the subtracted a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, item, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their inverse rest capacity, penalize occupied bins, and introduce a random factor proportional to the item's size relative to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a large value\\n penalty = np.where(bins > item, 0, 1e9)\\n \\n # Introduce a random factor proportional to the item's size relative to the bin's maximum capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + rand_factor\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a score that is a product of the inverse rest capacity and the inverse of the maximum capacity of the bin, then add a random term that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_capacity = 1 / bins\\n \\n # Calculate the random term\\n rand_term = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * inv_max_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, 100, size=len(bins)) * item\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a logarithm of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=inv_rest_capacity.shape)\\n inv_rest_capacity += rand_term\\n \\n # Take the logarithm of the sum of both terms\\n scores = np.log(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"`Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is dependent on a feature of the item relative to the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomness factor based on the item's size\\n randomness = np.random.randint(0, 100, size=len(bins))\\n randomness = randomness * (inv_rest_capacity > 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins inversely proportional to their available capacity, penalizes occupied bins, and accommodates small items through a constant relative to bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity for each bin\\n inv_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins by subtracting a constant value\\n penalty = np.where(bins > 0, 1, 0) * 10\\n \\n # Accommodate small items by adding a constant relative to bin size\\n small_item_bonus = np.where(item < 0.5 * bins, 1, 0) * 0.5\\n \\n # Calculate the final score for each bin\\n scores = inv_capacity + penalty + small_item_bonus\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a sine of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Take the sine of the sum of both terms\\n scores = np.sin(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum difference between the inverse rest capacity multiplied by the item size and the subtracted random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity multiplied by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the subtracted random term dependent on both the item size and the remaining capacity\\n rand_term = np.random.randint(0, item, size=len(bins)) * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * rand_term\\n \\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum additive of the inverse rest capacity and the subtracted a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, item, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum score calculated by subtracting a random term dependent on both the item size and the absolute difference between the item size and the remaining capacity from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, item, size=len(bins))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity - rand_term\\n \\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on the inverse of their remaining capacity and introduce a random factor proportional to both the item size and the bin's maximum capacity, while penalizing occupied bins using a multiplicative and subtractive approach.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the penalty for occupied bins\\n occupied_penalty = np.where(bins > 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = inv_capacity + rand_factor + occupied_penalty\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a score that is a product of the inverse rest capacity and the inverse of the maximum capacity of the bin, then add a random term that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_capacity = 1 / bins\\n \\n # Calculate the random term\\n rand_term = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * inv_max_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Prioritize bins by the product of the inverse rest capacity raised to a power and a randomized term based on the item's size relative to the bin's maximum capacity}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term based on the item's size relative to the bin's maximum capacity\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity ** 2 + rand_term\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, 100, size=len(bins)) * item\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a logarithm of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=inv_rest_capacity.shape)\\n inv_rest_capacity += rand_term\\n \\n # Take the logarithm of the sum of both terms\\n scores = np.log(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied a random term dependent on only the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term dependent on the item size\\n rand_term = np.random.randint(0, 100, size=len(bins)) * item\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins by a count of a function of inverse rest capacity, corrected by a random factor that is dependent on a feature of the item relative to the bin, with a penalty applied to bins whose inverse rest capacity is close to 0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Apply a random factor to the inverse rest capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n inv_rest_capacity *= rand_factor\\n \\n # Penalize bins with low inverse rest capacity\\n penalized_inv_rest_capacity = np.where(inv_rest_capacity < 0.5, inv_rest_capacity * 0.5, inv_rest_capacity)\\n \\n # Calculate the final score for each bin\\n scores = penalized_inv_rest_capacity + (1 - penalized_inv_rest_capacity) * np.log(penalized_inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a sine of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Take the sine of the sum of both terms\\n scores = np.sin(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum difference between the inverse rest capacity multiplied by the item size and the subtracted random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity multiplied by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the subtracted random term dependent on both the item size and the remaining capacity\\n rand_term = np.random.randint(0, item, size=len(bins)) * (bins - item)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * rand_term\\n \\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum additive of the inverse rest capacity and the subtracted a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, item, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the product of the inverse rest capacity and the logarithm of the item size, then deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity and the logarithm of the item size\\n scores = (1 / (bins - item)) * np.log(item)\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape[0])\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the minimum score calculated by subtracting a random term dependent on both the item size and the absolute difference between the item size and the remaining capacity from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, item, size=len(bins))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity - rand_term\\n \\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Use the square root of the inverse rest capacity divided by the maximum capacity and deduct a randomized term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the inverse rest capacity divided by the maximum capacity\\n scores = np.sqrt(1 / (bins - item))\\n \\n # Deduct a randomized term dependent on both the item size and the remaining capacity\\n scores -= np.random.randint(0, item, size=bins.shape) * (bins - item)\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the inverse rest capacity of each bin and penalize smaller bins, while introducing a random factor proportional to both the item's size and the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize smaller bins by adding a random factor\\n random_factor = np.random.randint(0, item, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Normalize the scores\\n scores = inv_rest_capacity / np.sum(inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes bins based on their inverse rest capacity, penalizes occupied bins but less than the previous algorithm, and compensates for small item sizes relative to bin maximum capacities but more than the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize occupied bins\\n penalty = np.where(bins == 0, 0, 1)\\n \\n # Compensate for small item sizes relative to bin maximum capacities\\n compensation = np.where(item < bins * 0.5, 1, 0)\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + penalty + compensation\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied a random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on the inverse of their remaining capacity and introduce a random factor proportional to both the item size and the bin's maximum capacity, while penalizing occupied bins using a multiplicative and subtractive approach.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.randint(0, 100, size=len(bins)) * (item + 1)\\n \\n # Calculate the penalty for occupied bins\\n occupied_penalty = np.where(bins > 0, 1, 0)\\n \\n # Calculate the total score for each bin\\n scores = inv_capacity + rand_factor + occupied_penalty\\n \\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a score that is a product of the inverse rest capacity and the inverse of the maximum capacity of the bin, then add a random term that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and inverse maximum capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n inv_max_capacity = 1 / bins\\n \\n # Calculate the random term\\n rand_term = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * inv_max_capacity + rand_term\\n \\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the highest score calculated by dividing the inverse rest capacity by the maximum bin capacity and subtracting a random factor proportional to the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the maximum bin capacity\\n max_bin_capacity = np.max(bins)\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity / max_bin_capacity\\n \\n # Subtract a random factor proportional to the remaining capacity\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n scores -= rand_factor * (1 - inv_rest_capacity)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting a randomized term that is a product of the item size and the inverse of the bin size from the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term\\n rand_term = np.random.randint(0, 100, size=len(bins)) * inv_rest_capacity\\n \\n # Subtract the randomized term from the inverse rest capacity\\n scores = inv_rest_capacity - rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by a score that is a function of inverse rest capacity, with a randomness factor that is proportional to the sum of the item's features relative to the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomness factor for each bin\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Prioritize bins by the product of the inverse rest capacity raised to a power and a randomized term based on the item's size relative to the bin's maximum capacity}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the randomized term based on the item's size relative to the bin's maximum capacity\\n rand_term = np.random.randint(0, 100, size=len(bins)) * (item / bins.max())\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity ** 2 + rand_term\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied random term dependent on both the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term for each bin\\n rand_term = np.random.randint(0, 100, size=len(bins)) * item\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the inverse rest capacity by the item size, add a randomized term based on the inverse remaining capacity, and take a logarithm of the sum of both terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a randomized term based on the inverse remaining capacity\\n rand_term = np.random.randint(0, 100, size=inv_rest_capacity.shape)\\n inv_rest_capacity += rand_term\\n \\n # Take the logarithm of the sum of both terms\\n scores = np.log(inv_rest_capacity + rand_term)\\n \\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum of the subtracted inverse rest capacity and the multiplied a random term dependent on only the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random term dependent on the item size\\n rand_term = np.random.randint(0, 100, size=len(bins)) * item\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + rand_term\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Modified algorithm uses a score function that combines inverse rest capacity and a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the inverse rest capacity and random factor\\n scores = inv_rest_capacity + random_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item. Then, multiply the scores by a weight that is inversely proportional to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.minimum(bins, item) * (1 / bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm 6: Score each bin by subtracting the squared difference between the bin's rest capacity and half of the bin's maximum capacity from the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the squared difference between the bin's rest capacity and half of the bin's maximum capacity\\n diff = (bins - item) ** 2\\n \\n # Subtract the squared difference from the bin's maximum capacity\\n scores = bins - diff\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with high remaining capacity, then low fullness level. Penalize bins with zero remaining capacity, then high fullness level.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with high remaining capacity\\n priority = np.argsort(-remaining_capacity)\\n \\n # Penalize bins with zero remaining capacity\\n penalty = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates scores inversely proportional to the rest capacities of bins, prioritizing bins with higher remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacities of the bins\\n inv_rest_capacities = 1 / (bins - item)\\n \\n # Prioritize bins with higher remaining capacity\\n scores = np.argsort(inv_rest_capacities)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the common idea of prioritizing bins with higher rest capacity, the new algorithm assigns scores by taking the square of the rest capacity and dividing it by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize bins with higher rest capacity\\n priority = np.argsort(rest_capacity)\\n \\n # Assign scores based on the square of the rest capacity and the index of the bin\\n scores = (rest_capacity**2 / priority).astype(np.float32)\\n \\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the square root of the ratio of item size to each bin's rest capacity while considering the condition that a bin's rest capacity should be larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the ratio of item size to each bin's rest capacity\\n scores = np.sqrt(item / bins)\\n \\n # Filter out bins with rest capacity less than or equal to the item size\\n scores = scores[bins > item]\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm considers the volume of the item and the remaining capacity of the bins to calculate scores, minimizing the number of used bins and the total unused space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the volume of the item\\n item_volume = item ** 3\\n \\n # Calculate the remaining capacity of each bin\\n bin_capacities = bins - item_volume\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bin_capacities[i] >= 0:\\n scores[i] = (bin_capacities[i] / item_volume) * (1 - (item_volume / bins[i]))\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: This algorithm calculates scores for each bin based on the product of rest capacity and inverse of bin index, giving higher priority to bins with larger capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the product of its rest capacity and inverse of its index\\n scores = np.multiply(bins, 1 / (np.arange(len(bins)) + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with low fullness level, then high remaining capacity. Penalize bins with high fullness level, then zero remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the fullness level of each bin\\n fullness = (bins - item) / bins\\n \\n # Prioritize bins with low fullness level\\n priority_score = 1 - fullness\\n \\n # Penalize bins with high fullness level\\n penalty_score = fullness ** 2\\n \\n # Combine the priority and penalty scores\\n scores = priority_score + penalty_score\\n \\n # Normalize the scores to ensure they are between 0 and 1\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by multiplying the ratio of the item's size to the bin's capacity with the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item's size to the bin's capacity\\n ratios = np.divide(item, bins)\\n \\n # Multiply the ratios by the bin's maximum capacity\\n scores = np.multiply(ratios, bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate bin scores based on the product of rest capacity and square root of bin index, favoring larger capacity bins with lower indices for higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the rest capacity and the square root of the bin index\\n scores = np.sqrt(bins) * (bins - item)\\n \\n # Favor larger capacity bins with lower indices for higher scores\\n scores[np.where(bins > item)] = np.inf\\n \\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function prioritizes bins with higher remaining capacity and lower fullness level, while penalizing bins with maximum capacity and high fullness level to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity and fullness level for each bin\\n remaining_capacity = bins - item\\n fullness_level = (bins - remaining_capacity) / bins\\n \\n # Prioritize bins with higher remaining capacity and lower fullness level\\n priority = np.where(remaining_capacity > 0, remaining_capacity, 0) + \\\\\\n np.where(fullness_level < 1, 1 - fullness_level, 0)\\n \\n # Penalize bins with maximum capacity and high fullness level\\n penalty = np.where(bins == max(bins), 1, 0) + \\\\\\n np.where(fullness_level >= 0.5, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority * (1 - penalty)\\n \\n return scores\",\n \"objective\": 0.05544,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of rest capacity and bin index, prioritizing bins with higher rest capacity and assigning a reasonable penalty for bins with a high index to encourage using fewer bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on a combination of rest capacity and bin index\\n scores = np.zeros(len(bins))\\n for i, bin in enumerate(bins):\\n if bin >= item:\\n scores[i] = (bin - item) / (i + 1)\\n else:\\n scores[i] = 0\\n \\n # Penalize bins with high indices to encourage using fewer bins\\n penalties = np.arange(len(bins)) ** 2\\n scores -= penalties\\n \\n return scores\",\n \"objective\": 0.06027,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm uses a score function that combines inverse rest capacity and a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the inverse rest capacity and random factor\\n scores = inv_rest_capacity + random_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting inverse rest capacity from total capacity, and introducing randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to enhance utilization\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying inverse rest capacity with total capacity, and introducing randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Introduce randomness to balance diversity\\n randomness = np.random.rand(len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * randomness\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Score function that combines inverse rest capacity, a random factor, and item-bin affinity to prioritize bins based on remaining capacity, randomness, and item-specific preferences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Generate a random factor for each bin\\n random_factor = np.random.rand(len(bins))\\n \\n # Calculate the item-bin affinity for each bin\\n item_bin_affinity = np.dot(item, bins)\\n \\n # Combine the three factors to get the final score\\n scores = inv_rest_capacity * random_factor * item_bin_affinity\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Design a score function that prioritizes bins with higher remaining capacity, penalizes bins with high fullness level, and assigns a bonus score based on the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins with high fullness level\\n fullness_level = (bins / item) ** 2\\n penalty = 1 - fullness_level\\n \\n # Assign a bonus score based on the bin's index\\n bonus = np.arange(len(bins)) + 1\\n \\n # Combine the three components into a single score\\n scores = remaining_capacity * penalty * bonus\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins based on ranking by total capacity and then score inversely proportional to item difference and a random factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the item difference\\n diff = 1 / (np.abs(item - bins) + 1e-6)\\n \\n # Calculate the random factor\\n rand = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin\\n scores = diff * rand\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that combines inverse rest capacity and a weighted random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the weighted random factor\\n rand_factor = np.random.rand(len(bins)) * 0.5 + 0.5\\n \\n # Combine the inverse rest capacity and weighted random factor\\n scores = inv_rest_capacity * rand_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item. Then, multiply the scores by a weight that is inversely proportional to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.minimum(bins, item) * (1 / bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm 6: Score each bin by subtracting the squared difference between the bin's rest capacity and half of the bin's maximum capacity from the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the squared difference between the bin's rest capacity and half of the bin's maximum capacity\\n diff = (bins - item) ** 2\\n \\n # Subtract the squared difference from the bin's maximum capacity\\n scores = bins - diff\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with high remaining capacity, then low fullness level. Penalize bins with zero remaining capacity, then high fullness level.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with high remaining capacity\\n priority = np.argsort(-remaining_capacity)\\n \\n # Penalize bins with zero remaining capacity\\n penalty = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates scores inversely proportional to the rest capacities of bins, prioritizing bins with higher remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacities of the bins\\n inv_rest_capacities = 1 / (bins - item)\\n \\n # Prioritize bins with higher remaining capacity\\n scores = np.argsort(inv_rest_capacities)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the common idea of prioritizing bins with higher rest capacity, the new algorithm assigns scores by taking the square of the rest capacity and dividing it by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize bins with higher rest capacity\\n priority = np.argsort(rest_capacity)\\n \\n # Assign scores based on the square of the rest capacity and the index of the bin\\n scores = (rest_capacity**2 / priority).astype(np.float32)\\n \\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by dividing the bin's maximum capacity by the sum of the bin's maximum capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.divide(bins.max(), bins.sum() + item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the square root of the ratio of item size to each bin's rest capacity while considering the condition that a bin's rest capacity should be larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the ratio of item size to each bin's rest capacity\\n scores = np.sqrt(item / bins)\\n \\n # Filter out bins with rest capacity less than or equal to the item size\\n scores = scores[bins > item]\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm considers the volume of the item and the remaining capacity of the bins to calculate scores, minimizing the number of used bins and the total unused space.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the volume of the item\\n item_volume = item ** 3\\n \\n # Calculate the remaining capacity of each bin\\n bin_capacities = bins - item_volume\\n \\n # Calculate the score for each bin\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bin_capacities[i] >= 0:\\n scores[i] = (bin_capacities[i] / item_volume) * (1 - (item_volume / bins[i]))\\n else:\\n scores[i] = 0\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: This algorithm calculates scores for each bin based on the product of rest capacity and inverse of bin index, giving higher priority to bins with larger capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the product of its rest capacity and inverse of its index\\n scores = np.multiply(bins, 1 / (np.arange(len(bins)) + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with low fullness level, then high remaining capacity. Penalize bins with high fullness level, then zero remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the fullness level of each bin\\n fullness = (bins - item) / bins\\n \\n # Prioritize bins with low fullness level\\n priority_score = 1 - fullness\\n \\n # Penalize bins with high fullness level\\n penalty_score = fullness ** 2\\n \\n # Combine the priority and penalty scores\\n scores = priority_score + penalty_score\\n \\n # Normalize the scores to ensure they are between 0 and 1\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm uses a score function that combines inverse rest capacity and a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the inverse rest capacity and random factor\\n scores = inv_rest_capacity + random_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting inverse rest capacity from total capacity, and introducing randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to enhance utilization\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by inverse rest capacity, introducing randomness with a constant value to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying inverse rest capacity with total capacity, and introducing randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Introduce randomness to balance diversity\\n randomness = np.random.rand(len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * randomness\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity by a random factor to introduce randomness\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity * random_factor\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the product of inverse rest capacity and a random number between 0 and the inverse rest capacity\\n randomness = np.random.uniform(size=len(bins)) * inv_rest_capacity\\n scores = inv_rest_capacity * randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Design a score function that prioritizes bins with higher remaining capacity, penalizes bins with high fullness level, and assigns a bonus score based on the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins with high fullness level\\n fullness_level = (bins / item) ** 2\\n penalty = 1 - fullness_level\\n \\n # Assign a bonus score based on the bin's index\\n bonus = np.arange(len(bins)) + 1\\n \\n # Combine the three components into a single score\\n scores = remaining_capacity * penalty * bonus\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins based on ranking by total capacity and then score inversely proportional to item difference and a random factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the item difference\\n diff = 1 / (np.abs(item - bins) + 1e-6)\\n \\n # Calculate the random factor\\n rand = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin\\n scores = diff * rand\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that combines inverse rest capacity and a weighted random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the weighted random factor\\n rand_factor = np.random.rand(len(bins)) * 0.5 + 0.5\\n \\n # Combine the inverse rest capacity and weighted random factor\\n scores = inv_rest_capacity * rand_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item. Then, multiply the scores by a weight that is inversely proportional to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.minimum(bins, item) * (1 / bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher density (score inversely proportional to the rest capacity over remaining maximum capacity) and introduce randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity over the maximum capacity\\n # for each bin, and multiply by a random value between 0 and 1\\n scores = np.random.rand(len(bins)) * (1 / (bins - item + 1))\\n \\n # Normalize the scores so that they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm 6: Score each bin by subtracting the squared difference between the bin's rest capacity and half of the bin's maximum capacity from the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the squared difference between the bin's rest capacity and half of the bin's maximum capacity\\n diff = (bins - item) ** 2\\n \\n # Subtract the squared difference from the bin's maximum capacity\\n scores = bins - diff\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Design a score function that prioritizes bins with both larger remaining capacity and smaller fullness level, and assigns a bonus score based on the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity and fullness level for each bin\\n remaining_capacity = bins - item\\n fullness_level = (bins - remaining_capacity) / bins\\n \\n # Prioritize bins with larger remaining capacity and smaller fullness level\\n priority = np.argsort(-remaining_capacity * fullness_level)\\n \\n # Assign a bonus score based on the bin's index\\n bonus_score = np.arange(len(priority)) + 1\\n \\n # Combine the priority and bonus scores to get the final scores\\n scores = priority * bonus_score\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with high remaining capacity, then low fullness level. Penalize bins with zero remaining capacity, then high fullness level.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Prioritize bins with high remaining capacity\\n priority = np.argsort(-remaining_capacity)\\n \\n # Penalize bins with zero remaining capacity\\n penalty = np.where(remaining_capacity == 0, 1, 0)\\n \\n # Combine the priority and penalty scores\\n scores = priority + penalty\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates scores inversely proportional to the rest capacities of bins, prioritizing bins with higher remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacities of the bins\\n inv_rest_capacities = 1 / (bins - item)\\n \\n # Prioritize bins with higher remaining capacity\\n scores = np.argsort(inv_rest_capacities)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the common idea of prioritizing bins with higher rest capacity, the new algorithm assigns scores by taking the square of the rest capacity and dividing it by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize bins with higher rest capacity\\n priority = np.argsort(rest_capacity)\\n \\n # Assign scores based on the square of the rest capacity and the index of the bin\\n scores = (rest_capacity**2 / priority).astype(np.float32)\\n \\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin by dividing the bin's maximum capacity by the sum of the bin's maximum capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.divide(bins.max(), bins.sum() + item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm uses a score function that combines inverse rest capacity and a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the inverse rest capacity and random factor\\n scores = inv_rest_capacity + random_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.rand(len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting inverse rest capacity from total capacity, and introducing randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to enhance utilization\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by inverse rest capacity, introducing randomness with a constant value to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a constant factor to prioritize bins with higher remaining capacity and then adding a random factor to introduce randomness and prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity by a constant factor to prioritize bins with higher remaining capacity\\n priority = inv_rest_capacity * 0.5\\n \\n # Add a random factor to introduce randomness and prevent constant assignment to the same bin\\n randomness = np.random.uniform(size=len(bins))\\n \\n # Combine the priority and randomness factors to get the final score for each bin\\n scores = priority + randomness\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity and penalize larger ones, while introducing a random factor based on the item's size relative to bin capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize larger bins by adding a random factor\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n penalized_inv_rest_capacity = inv_rest_capacity + random_factor\\n \\n # Calculate the scores for each bin\\n scores = penalized_inv_rest_capacity * (1 - random_factor)\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying inverse rest capacity with total capacity, and introducing randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Introduce randomness to balance diversity\\n randomness = np.random.rand(len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * randomness\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New Algorithm: Prioritize bins by multiplying the inverse rest capacity with a random number between 0 and 2}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity with a random number between 0 and 2\\n scores = inv_rest_capacity * np.random.uniform(0, 2, len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity by a random factor to introduce randomness\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity * random_factor\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the product of inverse rest capacity and a random number between 0 and 1\\n randomness = np.random.rand(len(bins))\\n scores = inv_rest_capacity * randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by adding randomness to the product of inverse rest capacity with a random number between 0 and the inverse rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the product of inverse rest capacity and a random number between 0 and the inverse rest capacity\\n randomness = np.random.uniform(size=len(bins)) * inv_rest_capacity\\n scores = inv_rest_capacity * randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Design a score function that prioritizes bins with higher remaining capacity, penalizes bins with high fullness level, and assigns a bonus score based on the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Penalize bins with high fullness level\\n fullness_level = (bins / item) ** 2\\n penalty = 1 - fullness_level\\n \\n # Assign a bonus score based on the bin's index\\n bonus = np.arange(len(bins)) + 1\\n \\n # Combine the three components into a single score\\n scores = remaining_capacity * penalty * bonus\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins based on ranking by total capacity and then score inversely proportional to item difference and a random factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the item difference\\n diff = 1 / (np.abs(item - bins) + 1e-6)\\n \\n # Calculate the random factor\\n rand = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin\\n scores = diff * rand\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that combines inverse rest capacity and a weighted random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the weighted random factor\\n rand_factor = np.random.rand(len(bins)) * 0.5 + 0.5\\n \\n # Combine the inverse rest capacity and weighted random factor\\n scores = inv_rest_capacity * rand_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item. Then, multiply the scores by a weight that is inversely proportional to the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.minimum(bins, item) * (1 / bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with higher density (score inversely proportional to the rest capacity over remaining maximum capacity) and introduce randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity over the maximum capacity\\n # for each bin, and multiply by a random value between 0 and 1\\n scores = np.random.rand(len(bins)) * (1 / (bins - item + 1))\\n \\n # Normalize the scores so that they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on a new score that considers rest capacity, remaining capacity, and a randomized component\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Calculate the remaining capacity of each bin\\n remaining_capacity = np.maximum(0, rest_capacity)\\n \\n # Calculate the randomized component\\n randomized_component = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the total score for each bin\\n scores = (remaining_capacity + randomized_component) / (rest_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm 6: Score each bin by subtracting the squared difference between the bin's rest capacity and half of the bin's maximum capacity from the bin's maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the squared difference between the bin's rest capacity and half of the bin's maximum capacity\\n diff = (bins - item) ** 2\\n \\n # Subtract the squared difference from the bin's maximum capacity\\n scores = bins - diff\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm uses a score function that combines inverse rest capacity and a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.rand(len(bins))\\n \\n # Combine the inverse rest capacity and random factor\\n scores = inv_rest_capacity + random_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm introduces a configurable parameter alpha that balances between prioritizing remaining capacity (alpha < 1) and randomness (alpha > 1) in the score function: score = (1 - alpha) * inv_rest_capacity + alpha * rand_factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, alpha=0.5):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin using the formula provided\\n scores = (1 - alpha) * inv_rest_capacity + alpha * rand_factor\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.rand(len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting inverse rest capacity from total capacity, and introducing randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to enhance utilization\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea of the provided algorithms is to combine the inverse rest capacity with a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin. The new algorithm uses a score function that combines a random factor with the number of bins to divide the inverse rest capacity and then adds a constant value to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to prioritize bins with higher remaining capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Divide by the number of bins to normalize the scores\\n scores = inv_rest_capacity / len(bins)\\n \\n # Add a constant value to the scores to ensure that all bins are considered\\n scores += 1\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by inverse rest capacity, introducing randomness with a constant value to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm multiplies the inverse of the remaining capacity by a constant factor to prioritize bins with higher remaining capacity, adds a random factor to introduce randomness, and divides the result by the total capacity to normalize the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse of the remaining capacity by a constant factor\\n # to prioritize bins with higher remaining capacity\\n priority_factor = 0.5\\n scores = inv_remaining_capacity * priority_factor\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.uniform(size=len(bins))\\n scores += random_factor\\n \\n # Normalize the scores by dividing them by the total capacity\\n total_capacity = np.sum(bins)\\n scores /= total_capacity\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a constant factor to prioritize bins with higher remaining capacity and then adding a random factor to introduce randomness and prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity by a constant factor to prioritize bins with higher remaining capacity\\n priority = inv_rest_capacity * 0.5\\n \\n # Add a random factor to introduce randomness and prevent constant assignment to the same bin\\n randomness = np.random.uniform(size=len(bins))\\n \\n # Combine the priority and randomness factors to get the final score for each bin\\n scores = priority + randomness\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity and penalize larger ones, while introducing a random factor based on the item's size relative to bin capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize larger bins by adding a random factor\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n penalized_inv_rest_capacity = inv_rest_capacity + random_factor\\n \\n # Calculate the scores for each bin\\n scores = penalized_inv_rest_capacity * (1 - random_factor)\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher remaining capacity using a score function that combines the inverse rest capacity with a diminishing random factor, starting with a higher random factor for bins with larger rest capacities and gradually decreasing the factor as the item is assigned to bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the diminishing random factor for each bin\\n rand_factor = np.random.uniform(0, 1, len(bins))\\n rand_factor[rand_factor > 0.5] *= 2\\n \\n # Combine the inverse rest capacity and random factor for each bin\\n scores = inv_rest_capacity + rand_factor\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns the item to the bin with the highest score calculated by adding a small constant to the inverse rest capacity and multiplying it with a squared random factor to increase randomness and prioritize bins with higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a small constant to the inverse rest capacity\\n inv_rest_capacity += 0.01\\n \\n # Multiply the inverse rest capacity by a squared random factor\\n # to increase randomness and prioritize bins with higher remaining capacity\\n random_factor = np.random.randint(0, 100, size=len(bins)) ** 2\\n scores = inv_rest_capacity * random_factor\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns the item to the bin with the highest score calculated by multiplying the inverse rest capacity with a squared random factor for increased randomness and prioritization of bins with higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the squared random factor for increased randomness and prioritization of bins with higher remaining capacity\\n rand_factor = np.random.rand(len(bins)) ** 2\\n \\n # Multiply the inverse rest capacity and squared random factor to get the final score for each bin\\n scores = inv_rest_capacity * rand_factor\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by multiplying the inverse rest capacity with a random number between 0 and 3\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity with a random number between 0 and 3\\n scores = inv_rest_capacity * np.random.randint(0, 3, size=len(bins))\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by multiplying inverse rest capacity with total capacity, and introducing randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Introduce randomness to balance diversity\\n randomness = np.random.rand(len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * randomness\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New Algorithm: Prioritize bins by multiplying the inverse rest capacity with a random number between 0 and 2}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity with a random number between 0 and 2\\n scores = inv_rest_capacity * np.random.uniform(0, 2, len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity by a random factor to introduce randomness\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity * random_factor\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign bins based on a score calculated by dividing the sum of inverse rest capacity and a random factor with the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor\\n rand_factor = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin\\n scores = inv_rest_capacity * rand_factor\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the bin index, introducing randomness, and then taking the logarithm of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.rand(len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Take the logarithm of the scores\\n scores = np.log(scores)\\n \\n return scores\",\n \"objective\": 0.02767,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm introduces a configurable parameter alpha that balances between prioritizing remaining capacity (alpha < 1) and randomness (alpha > 1) in the score function: score = (1 - alpha) * inv_rest_capacity + alpha * rand_factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, alpha=0.5):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin using the formula provided\\n scores = (1 - alpha) * inv_rest_capacity + alpha * rand_factor\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.rand(len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting inverse rest capacity from total capacity, and introducing randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to enhance utilization\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea of the provided algorithms is to combine the inverse rest capacity with a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin. The new algorithm uses a score function that combines a random factor with the number of bins to divide the inverse rest capacity and then adds a constant value to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to prioritize bins with higher remaining capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Divide by the number of bins to normalize the scores\\n scores = inv_rest_capacity / len(bins)\\n \\n # Add a constant value to the scores to ensure that all bins are considered\\n scores += 1\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 0.5, size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by inverse rest capacity, introducing randomness with a constant value to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by calculating the product of the inverse rest capacity with a score based on the item's size relative to the bin capacity and applying a random factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity with a score based on the item's size relative to the bin capacity\\n scores = (1 / (bins - item)) * (item / bins)\\n \\n # Apply a random factor to the scores\\n scores += np.random.uniform(0, 1, size=len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm assigns the item to the bin with the highest score calculated by subtracting a squared random factor from the inverse rest capacity to prioritize bins with lower remaining capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Subtract a squared random factor from the inverse rest capacity\\n # to prioritize bins with lower remaining capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins)) ** 2\\n scores = inv_rest_capacity - random_factor\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate a score for each bin by dividing the inverse rest capacity by a term that combines the item size and normalized bin capacity, and then adding a random factor to prioritize bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the normalized bin capacity\\n norm_bin_capacity = bins / np.sum(bins)\\n \\n # Combine the item size and normalized bin capacity\\n combined = item * norm_bin_capacity\\n \\n # Add a random factor to prioritize bins with lower remaining capacity\\n random_factor = np.random.rand(len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + combined + random_factor\\n \\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm multiplies the inverse of the remaining capacity by a constant factor to prioritize bins with higher remaining capacity, adds a random factor to introduce randomness, and divides the result by the total capacity to normalize the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse of the remaining capacity by a constant factor\\n # to prioritize bins with higher remaining capacity\\n priority_factor = 0.5\\n scores = inv_remaining_capacity * priority_factor\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.uniform(size=len(bins))\\n scores += random_factor\\n \\n # Normalize the scores by dividing them by the total capacity\\n total_capacity = np.sum(bins)\\n scores /= total_capacity\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a constant factor to prioritize bins with higher remaining capacity and then adding a random factor to introduce randomness and prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity by a constant factor to prioritize bins with higher remaining capacity\\n priority = inv_rest_capacity * 0.5\\n \\n # Add a random factor to introduce randomness and prevent constant assignment to the same bin\\n randomness = np.random.uniform(size=len(bins))\\n \\n # Combine the priority and randomness factors to get the final score for each bin\\n scores = priority + randomness\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity and penalize larger ones, while introducing a random factor based on the item's size relative to bin capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize larger bins by adding a random factor\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n penalized_inv_rest_capacity = inv_rest_capacity + random_factor\\n \\n # Calculate the scores for each bin\\n scores = penalized_inv_rest_capacity * (1 - random_factor)\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher remaining capacity using a score function that combines the inverse rest capacity with a diminishing random factor, starting with a higher random factor for bins with larger rest capacities and gradually decreasing the factor as the item is assigned to bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the diminishing random factor for each bin\\n rand_factor = np.random.uniform(0, 1, len(bins))\\n rand_factor[rand_factor > 0.5] *= 2\\n \\n # Combine the inverse rest capacity and random factor for each bin\\n scores = inv_rest_capacity + rand_factor\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.03511,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a constant factor and then adds a random factor weighted by a tunable parameter to balance the influence of capacity and randomness on bin selection.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity with a constant factor\\n const_factor = 0.5\\n scores = inv_rest_capacity * const_factor\\n \\n # Add a random factor weighted by a tunable parameter\\n random_factor = np.random.uniform(size=len(bins))\\n scores += random_factor * 0.1\\n \\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama34b/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm prioritizes larger bins by their rest capacity and penalizes smaller ones, while introducing a random factor based on the item's size relative to bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacity = bins - item\\n \\n # Prioritize larger bins by their rest capacity\\n priority = np.argsort(-rest_capacity)\\n \\n # Penalize smaller bins\\n penalty = np.exp(-np.log(rest_capacity))\\n \\n # Introduce a random factor based on the item's size relative to bin capacity\\n randomness = np.random.randint(0, 100, size=len(bins))\\n \\n # Combine the priority, penalty, and randomness to get the final score\\n scores = (priority + penalty + randomness) / 3\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize larger bins by their inverse rest capacity, penalizing smaller ones, while introducing a random factor proportional to the item's size relative to the maximum capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the penalty for smaller bins\\n penalty = np.maximum(0, (bins - item) / (bins + 1))\\n \\n # Calculate the random factor\\n rand_factor = np.random.randint(0, 100, size=len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity * (1 - penalty) + rand_factor\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with larger rest capacity and higher total capacity by combining inverse rest capacity and total capacity, introducing randomness to prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity and total capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n total_capacity = np.sum(bins)\\n \\n # Combine the inverse rest capacity and total capacity using a weighted average\\n weighted_average = 0.5 * inv_rest_capacity + 0.5 * total_capacity\\n \\n # Add randomness to the scores to prevent constant assignment to the same bin\\n randomness = np.random.randint(0, 10, size=len(bins))\\n scores = weighted_average + randomness\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by inverse rest capacity, introducing randomness with a random number sampled from a uniform distribution with a range [0, constant].\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by dividing the inverse rest capacity by the bin index, introducing randomness, and then taking the logarithm of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n randomness = np.random.rand(len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Take the logarithm of the scores\\n scores = np.log(scores)\\n \\n return scores\",\n \"objective\": 0.02767,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding a random number between 0 and 1 to the sum of the inverse rest capacity with the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random number between 0 and 1 to the sum of the inverse rest capacity\\n # and the bin's capacity\\n scores = inv_rest_capacity + np.random.uniform(size=len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm introduces a configurable parameter alpha that balances between prioritizing remaining capacity (alpha < 1) and randomness (alpha > 1) in the score function: score = (1 - alpha) * inv_rest_capacity + alpha * rand_factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, alpha=0.5):\\n # Calculate the inverse of the remaining capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the random factor for each bin\\n rand_factor = np.random.rand(len(bins))\\n \\n # Calculate the score for each bin using the formula provided\\n scores = (1 - alpha) * inv_rest_capacity + alpha * rand_factor\\n \\n return scores\",\n \"objective\": 0.02888,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by dividing the inverse rest capacity by the total capacity and introduce randomness to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + randomness\\n \\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.rand(len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by subtracting inverse rest capacity from total capacity, and introducing randomness to enhance utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to enhance utilization\\n randomness = np.random.uniform(0, 1, size=len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea of the provided algorithms is to combine the inverse rest capacity with a random factor to prioritize bins with higher remaining capacity while introducing randomness to prevent constant assignment to the same bin. The new algorithm uses a score function that combines a random factor with the number of bins to divide the inverse rest capacity and then adds a constant value to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add a random factor to prioritize bins with higher remaining capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n inv_rest_capacity += random_factor\\n \\n # Divide by the number of bins to normalize the scores\\n scores = inv_rest_capacity / len(bins)\\n \\n # Add a constant value to the scores to ensure that all bins are considered\\n scores += 1\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins by adding randomness to the sum of inverse rest capacity with a random number between 0 and 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores\\n random_component = np.random.uniform(0, 0.5, size=len(bins))\\n scores = inv_rest_capacity + random_component\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins by inverse rest capacity, introducing randomness with a constant value to balance diversity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Add randomness to the scores to balance diversity\\n randomness = np.random.uniform(0, 1, len(bins))\\n scores = inv_rest_capacity + randomness\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins by calculating the product of the inverse rest capacity with a score based on the item's size relative to the bin capacity and applying a random factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the inverse rest capacity with a score based on the item's size relative to the bin capacity\\n scores = (1 / (bins - item)) * (item / bins)\\n \\n # Apply a random factor to the scores\\n scores += np.random.uniform(0, 1, size=len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm assigns the item to the bin with the highest score calculated by subtracting a squared random factor from the inverse rest capacity to prioritize bins with lower remaining capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Subtract a squared random factor from the inverse rest capacity\\n # to prioritize bins with lower remaining capacity\\n random_factor = np.random.uniform(0, 1, size=len(bins)) ** 2\\n scores = inv_rest_capacity - random_factor\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate a score for each bin by dividing the inverse rest capacity by a term that combines the item size and normalized bin capacity, and then adding a random factor to prioritize bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the normalized bin capacity\\n norm_bin_capacity = bins / np.sum(bins)\\n \\n # Combine the item size and normalized bin capacity\\n combined = item * norm_bin_capacity\\n \\n # Add a random factor to prioritize bins with lower remaining capacity\\n random_factor = np.random.rand(len(bins))\\n \\n # Calculate the final score for each bin\\n scores = inv_rest_capacity + combined + random_factor\\n \\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm multiplies the inverse of the remaining capacity by a constant factor to prioritize bins with higher remaining capacity, adds a random factor to introduce randomness, and divides the result by the total capacity to normalize the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity\\n inv_remaining_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse of the remaining capacity by a constant factor\\n # to prioritize bins with higher remaining capacity\\n priority_factor = 0.5\\n scores = inv_remaining_capacity * priority_factor\\n \\n # Add a random factor to introduce randomness\\n random_factor = np.random.uniform(size=len(bins))\\n scores += random_factor\\n \\n # Normalize the scores by dividing them by the total capacity\\n total_capacity = np.sum(bins)\\n scores /= total_capacity\\n \\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses a score function that multiplies the inverse rest capacity with a constant factor to prioritize bins with higher remaining capacity and then adding a random factor to introduce randomness and prevent constant assignment to the same bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Multiply the inverse rest capacity by a constant factor to prioritize bins with higher remaining capacity\\n priority = inv_rest_capacity * 0.5\\n \\n # Add a random factor to introduce randomness and prevent constant assignment to the same bin\\n randomness = np.random.uniform(size=len(bins))\\n \\n # Combine the priority and randomness factors to get the final score for each bin\\n scores = priority + randomness\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize smaller bins by their inverse rest capacity and penalize larger ones, while introducing a random factor based on the item's size relative to bin capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse rest capacity of each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Penalize larger bins by adding a random factor\\n random_factor = np.random.uniform(0, 1, size=len(bins))\\n penalized_inv_rest_capacity = inv_rest_capacity + random_factor\\n \\n # Calculate the scores for each bin\\n scores = penalized_inv_rest_capacity * (1 - random_factor)\\n \\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score as the multiplication of the item's capacity divided by the bin's remaining capacity, and the bin's index plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item's capacity and the bin's remaining capacity\\n scores = (item / bins) * (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Minimize the number of used bins while considering both the residual capacity and the difference between bin capacity and item size: score = (bins[i] - item) / max(bins[i] - item, min_capacity)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the residual capacity for each bin\\n residual_capacities = bins - item\\n \\n # Calculate the difference between the bin capacity and the item size\\n capacity_differences = bins - item\\n \\n # Calculate the scores for each bin based on the residual capacity and the capacity difference\\n scores = (residual_capacities / capacity_differences).clip(min=0)\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size, and using a logarithmic function to increase the penalty for using larger bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size\\n scores = (bins ** 2) / (bins - item)\\n \\n # Apply a logarithmic function to increase the penalty for using larger bins\\n scores = np.log(scores + 1)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign the item to the bin that has the highest score calculated by this function: (rest capacity - item size) / max(rest capacity - item size, 1), excluding bins with full capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / np.maximum(bins - item, 1)\\n \\n # Exclude bins with full capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score bins with their rest capacities raised to the power of their maximum capacity, assigning items to bins with the maximum score and excluding bins with maximum rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its rest capacity raised to the power of its maximum capacity\\n scores = np.power(bins, item)\\n \\n # Exclude bins with maximum rest capacity from the scores\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.06932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{ New algorithm: Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin's index, and using a logarithmic function to increase the penalty for using larger bins. }\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin's index, and using a logarithmic function to increase the penalty for using larger bins\\n scores = np.log(np.abs(bins - item)) / (np.abs(bins - item) + 1) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.06993,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index\\n scores = -np.log(bins / item) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of a bin as the product of the difference between its maximum and current capacity and the reciprocal of the capacity difference between the bin and the item, multiplied by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (bins - item) * (1 / (bins - item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + ((1 - bins) * (1 / (item - bins)))\\n \\n # Normalize the scores to ensure they add up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index\\n scores = (bins / item) - np.arange(len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiply each bin's capacity by the square of the reciprocal of the bin's index, multiplied by the square root of the reciprocal of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the formula provided\\n scores = (bins * (np.sqrt(item) / bins)) ** 2\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index\\n scores = -np.log(bins / item) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of a bin as the product of the difference between its maximum and current capacity and the reciprocal of the capacity difference between the bin and the item, multiplied by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (bins - item) * (1 / (bins - item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + ((1 - bins) * (1 / (item - bins)))\\n \\n # Normalize the scores to ensure they add up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index\\n scores = (bins / item) - np.arange(len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiply each bin's capacity by the square of the reciprocal of the bin's index, multiplied by the square root of the reciprocal of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the formula provided\\n scores = (bins * (np.sqrt(item) / bins)) ** 2\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of the bin's capacity raised to a power and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins ** item) / (bins - item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of a bin as the product of the difference between its maximum and current capacity and the reciprocal of the capacity difference between the bin and the item, multiplied by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (bins - item) * (1 / (bins - item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the bin's index and the logarithm of the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the bin's index and the logarithm of the reciprocal of the difference between the bin's capacity and the item size\\n scores = np.log(np.reciprocal(bins - item)) * np.arange(len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + ((1 - bins) * (1 / (item - bins)))\\n \\n # Normalize the scores to ensure they add up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index\\n scores = (bins / item) - np.arange(len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiply each bin's capacity by the square of the reciprocal of the bin's index, multiplied by the square root of the reciprocal of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the formula provided\\n scores = (bins * (np.sqrt(item) / bins)) ** 2\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the reciprocal of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between the bin's capacity and the item size\\n scores = np.exp(-(bins - item)) / (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power\\n scores = np.exp(-((bins - item) ** 2)) * (np.arange(len(bins)) + 1) ** 0.5\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of the bin's capacity raised to a power and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins ** item) / (bins - item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score of a bin as the product of the bin's position and the difference between its maximum and current capacity, divided by the difference between the bin and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on its position and capacity\\n scores = (np.arange(len(bins)) + 1) * (bins - item) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the bin's index and the logarithm of the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the bin's index and the logarithm of the reciprocal of the difference between the bin's capacity and the item size\\n scores = np.log(np.reciprocal(bins - item)) * np.arange(len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin as the product of the bin's capacity minus the item size raised to a power, and then divide this value by the product of the bin's capacity and the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) ** 0.5 / (bins * (bins - item))\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the reciprocal of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between the bin's capacity and the item size\\n scores = np.exp(-(bins - item)) / (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power\\n scores = np.exp(-((bins - item) ** 2)) * (np.arange(len(bins)) + 1) ** 0.5\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of the bin's capacity raised to a power and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins ** item) / (bins - item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score of a bin as the product of the bin's position and the difference between its maximum and current capacity, divided by the difference between the bin and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on its position and capacity\\n scores = (np.arange(len(bins)) + 1) * (bins - item) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the bin's index and the logarithm of the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the bin's index and the logarithm of the reciprocal of the difference between the bin's capacity and the item size\\n scores = np.log(np.reciprocal(bins - item)) * np.arange(len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size\\n scores = (bins ** (np.arange(len(bins)) + 1)) / (bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the reciprocal of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between the bin's capacity and the item size\\n scores = np.exp(-(bins - item)) / (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power\\n scores = np.exp(-((bins - item) ** 2)) * (np.arange(len(bins)) + 1) ** 0.5\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of the bin's capacity raised to a power and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins ** item) / (bins - item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score of a bin as the product of the bin's position and the difference between its maximum and current capacity, divided by the difference between the bin and the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on its position and capacity\\n scores = (np.arange(len(bins)) + 1) * (bins - item) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size\\n scores = (bins ** (np.arange(len(bins)) + 1)) / (bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score of each bin as the square root of the reciprocal of the difference between its capacity and the item size, divided by the bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) / bins\\n \\n # Return the scores for all bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the reciprocal of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between the bin's capacity and the item size\\n scores = np.exp(-(bins - item)) / (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power\\n scores = np.exp(-((bins - item) ** 2)) * (np.arange(len(bins)) + 1) ** 0.5\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of the bin's capacity raised to a power and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins ** item) / (bins - item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as linear combination between the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(bins - item)) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size\\n scores = (bins ** (np.arange(len(bins)) + 1)) / (bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm: Calculate the scores for each bin as the product of the square root of the bin's capacity and the reciprocal of the difference between the bin's capacity and the item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) / (bins - item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score of each bin as the square root of the reciprocal of the difference between its capacity and the item size, divided by the bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) / bins\\n \\n # Return the scores for all bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the reciprocal of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between the bin's capacity and the item size\\n scores = np.exp(-(bins - item)) / (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power\\n scores = np.exp(-((bins - item) ** 2)) * (np.arange(len(bins)) + 1) ** 0.5\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the product of the bin's capacity raised to a power and the reciprocal of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins ** item) / (bins - item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as linear combination between the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(bins - item)) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size\\n scores = (bins ** (np.arange(len(bins)) + 1)) / (bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to bin indices\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of bin capacities and the square of item size\\n diff = np.square(bins) - np.square(item)\\n # Divide the sum of rest capacities by the difference\\n scores = rest_capacities / diff\\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * item) / (np.square(bins) - np.square(item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\\n scores = np.exp(-((bins - item) ** 2)) + np.sqrt(np.arange(len(bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm: Calculate the scores for each bin as the product of the square root of the bin's capacity and the reciprocal of the difference between the bin's capacity and the item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) / (bins - item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score of each bin as the square root of the reciprocal of the difference between its capacity and the item size, divided by the bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) / bins\\n \\n # Return the scores for all bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the reciprocal of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between the bin's capacity and the item size\\n scores = np.exp(-(bins - item)) / (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores equivalently as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores equivalently as the product of exponential of the difference between the rest capacity of the bin and the item size and the bin's index raised to a power\\n scores = np.exp(-((bins - item) ** 2)) * (np.arange(len(bins)) + 1) ** 0.5\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the inverse of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to the power of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin's capacity and the item size\\n reciprocal_diff = 1 / (bins - item)\\n \\n # Calculate the bin's index raised to the power of the rest capacity\\n powered_index = np.power(np.arange(len(bins)), bins)\\n \\n # Multiply the reciprocal difference and the powered index\\n scores = reciprocal_diff * powered_index\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size\\n scores = (bins ** (np.arange(len(bins)) + 1)) / (bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, multiplied by bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the power of the bin index\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of the bin capacity and the square of the item size\\n diff = np.square(bins) - np.square(item)\\n # Calculate the scores for each bin\\n scores = (rest_capacities / diff) * bins\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to bin indices\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of bin capacities and the square of item size\\n diff = np.square(bins) - np.square(item)\\n # Divide the sum of rest capacities by the difference\\n scores = rest_capacities / diff\\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * item) / (np.square(bins) - np.square(item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\\n scores = np.exp(-((bins - item) ** 2)) + np.sqrt(np.arange(len(bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm: Calculate the scores for each bin as the product of the square root of the bin's capacity and the reciprocal of the difference between the bin's capacity and the item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) / (bins - item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score of each bin as the square root of the reciprocal of the difference between its capacity and the item size, divided by the bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) / bins\\n \\n # Return the scores for all bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each feasible bin as the sum of the square of the bin's rest capacity and the negative of item size multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = -np.square(bins) * item\\n \\n # Add the rest capacity of each bin to the scores\\n scores += bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity\\n scores = (np.reciprocal(np.abs(bins - item)) ** 0.5) / bins\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculating scores based on rest capacities and item size, assigning items to bins with the highest score, using a score function of (item / rest capacity) to maximize bin utilization and minimize used bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its rest capacity and item size\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item / bins[i]\\n else:\\n scores[i] = 0\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the square root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the square root of the bin's index\\n scores = (np.reciprocal(bins - item) * np.sqrt(np.arange(len(bins))))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size, and using a logarithmic function to increase the penalty for using larger bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size\\n scores = (bins ** 2) / (bins - item)\\n \\n # Apply a logarithmic function to increase the penalty for using larger bins\\n scores = np.log(scores + 1)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate bin score using the natural logarithm of the ratio of item size to the difference between bin rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic ratio of item size to bin rest capacity\\n ratios = np.log(item / (bins - item))\\n \\n # Calculate the scores for each bin based on the ratios\\n scores = ratios * (bins - item)\\n \\n return scores\",\n \"objective\": 0.05081,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score of a bin by subtracting the item size from the bin's rest capacity, dividing it by the difference between the bin's rest capacity and the maximum bin capacity, then adding 1 and finally taking the natural logarithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.log((bins - item) / (bins - max(bins))) + 1\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the reciprocal of the bin's index, using a logarithmic function with a scaling factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the reciprocal of the bin's index, using a logarithmic function with a scaling factor of 0.5\\n scores = np.log(np.abs(bins - item)) / (np.log(bins) + 0.5)\\n \\n # Scale the scores by the reciprocal of the bin's index\\n scores *= 1 / np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.05946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score bins with their rest capacities raised to the power of their maximum capacity, assigning items to bins with the maximum score and excluding bins with maximum rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its rest capacity raised to the power of its maximum capacity\\n scores = np.power(bins, item)\\n \\n # Exclude bins with maximum rest capacity from the scores\\n scores[bins == np.max(bins)] = 0\\n \\n return scores\",\n \"objective\": 0.06932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to the power of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin's capacity and the item size\\n reciprocal_diff = 1 / (bins - item)\\n \\n # Calculate the bin's index raised to the power of the rest capacity\\n powered_index = np.power(np.arange(len(bins)), bins)\\n \\n # Multiply the reciprocal difference and the powered index\\n scores = reciprocal_diff * powered_index\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size\\n scores = (bins ** (np.arange(len(bins)) + 1)) / (bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * np.arange(len(bins)) / (np.square(bins) - np.square(item)))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, multiplied by bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the power of the bin index\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of the bin capacity and the square of the item size\\n diff = np.square(bins) - np.square(item)\\n # Calculate the scores for each bin\\n scores = (rest_capacities / diff) * bins\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to bin indices\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of bin capacities and the square of item size\\n diff = np.square(bins) - np.square(item)\\n # Divide the sum of rest capacities by the difference\\n scores = rest_capacities / diff\\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * item) / (np.square(bins) - np.square(item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\\n scores = np.exp(-((bins - item) ** 2)) + np.sqrt(np.arange(len(bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm: Calculate the scores for each bin as the product of the square root of the bin's capacity and the reciprocal of the difference between the bin's capacity and the item size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) / (bins - item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score of each bin as the square root of the reciprocal of the difference between its capacity and the item size, divided by the bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) / bins\\n \\n # Return the scores for all bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the square root of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins))) + 1\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to the power of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin's capacity and the item size\\n reciprocal_diff = 1 / (bins - item)\\n \\n # Calculate the bin's index raised to the power of the rest capacity\\n powered_index = np.power(np.arange(len(bins)), bins)\\n \\n # Multiply the reciprocal difference and the powered index\\n scores = reciprocal_diff * powered_index\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between bin's capacity and the item size\\n scores = (bins ** (np.arange(len(bins)) + 1)) / (bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * np.arange(len(bins)) / (np.square(bins) - np.square(item)))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the product of the bin's index raised to the bin's rest capacity divided by the square root of the difference between the bin's capacity and item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the bin's index raised to the bin's rest capacity\\n # divided by the square root of the difference between the bin's capacity\\n # and item's size\\n scores = (np.arange(len(bins)) + 1) ** (bins - item) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, multiplied by bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the power of the bin index\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of the bin capacity and the square of the item size\\n diff = np.square(bins) - np.square(item)\\n # Calculate the scores for each bin\\n scores = (rest_capacities / diff) * bins\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size, where the weights are the square of the bin's index or the logarithm of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size\\n scores = (np.minimum(bins, item) / np.maximum(bins - item, 0)) ** 2 + (np.log(bins) / np.log(item)) ** 2\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * item) / (np.square(bins) - np.square(item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the square root of the bin's index\\n scores = np.exp(-((bins - item) ** 2)) + np.sqrt(np.arange(len(bins)))\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main steps: Adjust the rest capacities by dividing the rest capacities of all bins by the index of each bin, and then multiply this value by the square root of the capacity of the bin. Finally, divide this value by the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the adjusted rest capacities\\n adjusted_rest_capacities = bins / (np.arange(len(bins)) + 1) * np.sqrt(bins)\\n \\n # Calculate the scores\\n scores = adjusted_rest_capacities / abs(item - bins)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the product of the square root of rest capacity raised to the bin's index, multiplied by the bin index, divided by the difference between the bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to the bin's index, multiplied by the bin index, divided by the difference between the bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) * (np.arange(len(bins)) + 1) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the square root of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins))) + 1\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to the power of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin's capacity and the item size\\n reciprocal_diff = 1 / (bins - item)\\n \\n # Calculate the bin's index raised to the power of the rest capacity\\n powered_index = np.power(np.arange(len(bins)), bins)\\n \\n # Multiply the reciprocal difference and the powered index\\n scores = reciprocal_diff * powered_index\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the sum of bin's index raised to the power of rest capacity by the product of the square of item size and the square of the difference between bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the indices of the bins raised to the power of their rest capacities\\n idx_pow = np.power(np.arange(len(bins)), bins)\\n # Calculate the product of the square of the item size and the square of the difference between the bin's capacity and the item size\\n item_size_sq = np.square(item)\\n bin_capacity_diff_sq = np.square(bins - item)\\n # Calculate the scores for each bin based on the formula\\n scores = idx_pow / (item_size_sq * bin_capacity_diff_sq)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size, to prioritize bins with higher remaining capacity while accounting for item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size\\n scores = np.power(bins, np.arange(len(bins))) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * np.arange(len(bins)) / (np.square(bins) - np.square(item)))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the product of the bin's index raised to the bin's rest capacity divided by the square root of the difference between the bin's capacity and item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the bin's index raised to the bin's rest capacity\\n # divided by the square root of the difference between the bin's capacity\\n # and item's size\\n scores = (np.arange(len(bins)) + 1) ** (bins - item) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by multiplying its rest capacity with the inverse of the difference between its capacity and the item size, and then subtracting the bin's index from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the difference between the item size and the bin capacity\\n inv_diff = 1 / (np.array(bins) - item)\\n \\n # Multiply the inverse of the difference with the rest capacity of each bin\\n scores = inv_diff * np.array(bins)\\n \\n # Subtract the bin index from the scores\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, multiplied by bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the power of the bin index\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of the bin capacity and the square of the item size\\n diff = np.square(bins) - np.square(item)\\n # Calculate the scores for each bin\\n scores = (rest_capacities / diff) * bins\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size, where the weights are the square of the bin's index or the logarithm of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size\\n scores = (np.minimum(bins, item) / np.maximum(bins - item, 0)) ** 2 + (np.log(bins) / np.log(item)) ** 2\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * item) / (np.square(bins) - np.square(item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is the product of square root of rest capacity to the power of bin index multiplied by the sum of rest capacity and item size, divided by their difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) * (bins + item) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the square root of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins))) + 1\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to the power of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin's capacity and the item size\\n reciprocal_diff = 1 / (bins - item)\\n \\n # Calculate the bin's index raised to the power of the rest capacity\\n powered_index = np.power(np.arange(len(bins)), bins)\\n \\n # Multiply the reciprocal difference and the powered index\\n scores = reciprocal_diff * powered_index\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the sum of bin's index raised to the power of rest capacity by the product of the square of item size and the square of the difference between bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the indices of the bins raised to the power of their rest capacities\\n idx_pow = np.power(np.arange(len(bins)), bins)\\n # Calculate the product of the square of the item size and the square of the difference between the bin's capacity and the item size\\n item_size_sq = np.square(item)\\n bin_capacity_diff_sq = np.square(bins - item)\\n # Calculate the scores for each bin based on the formula\\n scores = idx_pow / (item_size_sq * bin_capacity_diff_sq)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size, to prioritize bins with higher remaining capacity while accounting for item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size\\n scores = np.power(bins, np.arange(len(bins))) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * np.arange(len(bins)) / (np.square(bins) - np.square(item)))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the product of the bin's index raised to the bin's rest capacity divided by the square root of the difference between the bin's capacity and item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the bin's index raised to the bin's rest capacity\\n # divided by the square root of the difference between the bin's capacity\\n # and item's size\\n scores = (np.arange(len(bins)) + 1) ** (bins - item) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by multiplying its rest capacity with the inverse of the difference between its capacity and the item size, and then subtracting the bin's index from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the difference between the item size and the bin capacity\\n inv_diff = 1 / (np.array(bins) - item)\\n \\n # Multiply the inverse of the difference with the rest capacity of each bin\\n scores = inv_diff * np.array(bins)\\n \\n # Subtract the bin index from the scores\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, multiplied by bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the power of the bin index\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of the bin capacity and the square of the item size\\n diff = np.square(bins) - np.square(item)\\n # Calculate the scores for each bin\\n scores = (rest_capacities / diff) * bins\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size, where the weights are the square of the bin's index or the logarithm of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size\\n scores = (np.minimum(bins, item) / np.maximum(bins - item, 0)) ** 2 + (np.log(bins) / np.log(item)) ** 2\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, to account for limited capacity while encouraging bins with higher remaining capacity to be used first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * item) / (np.square(bins) - np.square(item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is the product of square root of rest capacity to the power of bin index multiplied by the sum of rest capacity and item size, divided by their difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) * (bins + item) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the square root of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins))) + 1\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to the power of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin's capacity and the item size\\n reciprocal_diff = 1 / (bins - item)\\n \\n # Calculate the bin's index raised to the power of the rest capacity\\n powered_index = np.power(np.arange(len(bins)), bins)\\n \\n # Multiply the reciprocal difference and the powered index\\n scores = reciprocal_diff * powered_index\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the sum of bin's index raised to the power of rest capacity by the product of the square of item size and the square of the difference between bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the indices of the bins raised to the power of their rest capacities\\n idx_pow = np.power(np.arange(len(bins)), bins)\\n # Calculate the product of the square of the item size and the square of the difference between the bin's capacity and the item size\\n item_size_sq = np.square(item)\\n bin_capacity_diff_sq = np.square(bins - item)\\n # Calculate the scores for each bin based on the formula\\n scores = idx_pow / (item_size_sq * bin_capacity_diff_sq)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size, to prioritize bins with higher remaining capacity while accounting for item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size\\n scores = np.power(bins, np.arange(len(bins))) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * np.arange(len(bins)) / (np.square(bins) - np.square(item)))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the product of the bin's index raised to the bin's rest capacity divided by the power of the difference between the bin's capacity and item's size with the power being a new parameter.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the bin's index raised to the bin's rest capacity\\n # divided by the power of the difference between the bin's capacity and item's size\\n scores = (np.arange(len(bins)) + 1) ** (bins - item) / (bins - item) ** 0.5\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the difference between the bin's capacity raised to the bin's index and the item size raised to the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin's capacity raised to the bin's index and the item size raised to the bin's index\\n diff = (bins ** (np.arange(len(bins)) + 1) - item ** (np.arange(len(bins)) + 1))\\n \\n # Divide the difference by the difference between the square of bin's capacity and the square of item size\\n scores = diff / (bins ** 2 - item ** 2)\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by multiplying its rest capacity with the inverse of the difference between its capacity and the item size, and then subtracting the bin's index from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the difference between the item size and the bin capacity\\n inv_diff = 1 / (np.array(bins) - item)\\n \\n # Multiply the inverse of the difference with the rest capacity of each bin\\n scores = inv_diff * np.array(bins)\\n \\n # Subtract the bin index from the scores\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, multiplied by bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the power of the bin index\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of the bin capacity and the square of the item size\\n diff = np.square(bins) - np.square(item)\\n # Calculate the scores for each bin\\n scores = (rest_capacities / diff) * bins\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size, where the weights are the square of the bin's index or the logarithm of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size\\n scores = (np.minimum(bins, item) / np.maximum(bins - item, 0)) ** 2 + (np.log(bins) / np.log(item)) ** 2\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the square root of rest capacity raised to bin's index, divided by the square root of the difference between bin's capacity and the item size\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) / np.sqrt(bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is the product of square root of rest capacity to the power of bin index multiplied by the sum of rest capacity and item size, divided by their difference.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) ** (np.arange(len(bins)) + 1) * (bins + item) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the square root of the bin's index or the square root of the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins)) + 1) / np.sqrt(len(bins))\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the square root of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n weights = np.sqrt(np.arange(len(bins))) + 1\\n scores = (weights * bins) / (item - bins)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to each bin the value of the rest capacity raised to the power of the index of that bin, and then divide this value by the square root of the absolute difference between the current capacity and the size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities raised to the power of the index of each bin\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the absolute difference between the current capacity and the size of the item\\n abs_diff = np.abs(np.subtract(bins, item))\\n \\n # Divide the rest capacities by the square root of the absolute difference\\n scores = np.divide(rest_capacities, np.sqrt(abs_diff))\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign score to each bin as the multiplication of the reciprocal of the difference between the bin's rest capacity and the item size and the bin's index raised to the power of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin's rest capacity and the item size\\n reciprocal_diff = 1 / (bins - item)\\n \\n # Raise the bin's index to the power of the rest capacity\\n powered_index = np.power(np.arange(len(bins)), bins)\\n \\n # Multiply the reciprocal difference and the powered index\\n scores = reciprocal_diff * powered_index\\n \\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Divide the sum of bin's index raised to the power of rest capacity by the product of the square of item size and the square of the difference between bin's capacity and the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the indices of the bins raised to the power of their rest capacities\\n idx_pow = np.power(np.arange(len(bins)), bins)\\n # Calculate the product of the square of the item size and the square of the difference between the bin's capacity and the item size\\n item_size_sq = np.square(item)\\n bin_capacity_diff_sq = np.square(bins - item)\\n # Calculate the scores for each bin based on the formula\\n scores = idx_pow / (item_size_sq * bin_capacity_diff_sq)\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size, to prioritize bins with higher remaining capacity while accounting for item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin as the rest capacity raised to the bin's index divided by the difference between the capacity and the item size\\n scores = np.power(bins, np.arange(len(bins))) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated algorithm: Compute the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the bin's index, multiplied by the bin's index, divided by the difference between the square of bin's capacity and the square of item size\\n scores = (np.power(bins, np.arange(len(bins))) * np.arange(len(bins)) / (np.square(bins) - np.square(item)))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the product of the bin's index raised to the bin's rest capacity divided by the power of the difference between the bin's capacity and item's size with the power being a new parameter.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the bin's index raised to the bin's rest capacity\\n # divided by the power of the difference between the bin's capacity and item's size\\n scores = (np.arange(len(bins)) + 1) ** (bins - item) / (bins - item) ** 0.5\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the difference between the bin's capacity raised to the bin's index and the item size raised to the bin's index, divided by the difference between the square of bin's capacity and the square of item size, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the bin's capacity raised to the bin's index and the item size raised to the bin's index\\n diff = (bins ** (np.arange(len(bins)) + 1) - item ** (np.arange(len(bins)) + 1))\\n \\n # Divide the difference by the difference between the square of bin's capacity and the square of item size\\n scores = diff / (bins ** 2 - item ** 2)\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square root of the exponential of the difference between the rest capacity of the bin and the item size and the bin's index\\n scores = np.sqrt(np.exp(-((bins - item) ** 2)))\\n \\n # Add a small value to avoid division by zero\\n scores += 1e-6\\n \\n # Normalize the scores to ensure they sum up to 1\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm Description: Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the exponential of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.exp(-np.abs(bins - item)) + np.log(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by multiplying its rest capacity with the inverse of the difference between its capacity and the item size, and then subtracting the bin's index from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the difference between the item size and the bin capacity\\n inv_diff = 1 / (np.array(bins) - item)\\n \\n # Multiply the inverse of the difference with the rest capacity of each bin\\n scores = inv_diff * np.array(bins)\\n \\n # Subtract the bin index from the scores\\n scores -= np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the sum of rest capacity raised to bin's index, divided by the difference between the square of bin's capacity and the square of item size, multiplied by bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of rest capacities raised to the power of the bin index\\n rest_capacities = np.power(bins, np.arange(len(bins)))\\n # Calculate the difference between the square of the bin capacity and the square of the item size\\n diff = np.square(bins) - np.square(item)\\n # Calculate the scores for each bin\\n scores = (rest_capacities / diff) * bins\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the sum of the remaining capacity and the reciprocal of the bin's index multiplied by the reciprocal of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the reciprocal of the bin index and the reciprocal of the remaining capacity\\n reciprocal_bin_index = 1 / (np.arange(len(bins)) + 1)\\n reciprocal_remaining_capacity = 1 / remaining_capacity\\n \\n # Calculate the score for each bin\\n scores = reciprocal_bin_index * reciprocal_remaining_capacity\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size, where the weights are the square of the bin's index or the logarithm of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as a weighted sum of the number of items it can still accommodate and the reciprocal of the difference between its capacity and the item size\\n scores = (np.minimum(bins, item) / np.maximum(bins - item, 0)) ** 2 + (np.log(bins) / np.log(item)) ** 2\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"For each bin, score is computed as a weighted sum of the bin's capacity, rest capacity, and the reciprocal of the difference between the capacity and the item size, where the weights are inversely proportional to the square root of the bin's index, capacity, and rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin based on the given formula\\n scores = (np.sqrt(bins) * item / (bins - item)) + (np.sqrt(bins) * (bins - item) / (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each feasible bin as the sum of the inverse of the bin's rest capacity and the negative of item size squared multiplied by the square of the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = -np.square(item) * np.square(bins) / (bins + 1e-8)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity\\n scores = (np.reciprocal(np.abs(bins - item)) ** 0.5) / bins\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores for bins based on a power function of the ratio of item size to bin rest capacity, with the power being the ratio of the sum of bin rest capacities to total bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power function of the ratio of item size to bin rest capacity\\n power = (sum(bins) / len(bins)) ** (len(bins) - 1)\\n # Calculate the scores for each bin based on the power function\\n scores = np.power(item / bins, power)\\n # Return the scores\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the arithmetic mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average rest capacity and maximum capacity\\n avg_rest = np.mean(bins)\\n max_capacity = np.max(bins)\\n \\n # Apply a penalty to bins with more than half of the maximum capacity\\n penalties = np.where(bins > max_capacity / 2, 0.5 * (max_capacity - bins), 0)\\n \\n # Calculate the scores for each bin\\n scores = avg_rest + penalties\\n \\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the square root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the square root of the bin's index\\n scores = (np.reciprocal(bins - item) * np.sqrt(np.arange(len(bins))))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size, and using a logarithmic function to increase the penalty for using larger bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size\\n scores = (bins ** 2) / (bins - item)\\n \\n # Apply a logarithmic function to increase the penalty for using larger bins\\n scores = np.log(scores + 1)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the ratio of item size to each bin's rest capacity, and the product of the ratio and the rest capacity.\\n2. Calculate the score for each bin based on the ratio and the product.\\n3. Return the scores for the bins for assignment\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item size to each bin's rest capacity\\n ratios = np.divide(item, bins)\\n \\n # Calculate the product of the ratio and the rest capacity\\n products = np.multiply(ratios, bins)\\n \\n # Calculate the score for each bin based on the ratio and the product\\n scores = np.maximum(products, 0)\\n \\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate bin score using the natural logarithm of the ratio of item size to the difference between bin rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic ratio of item size to bin rest capacity\\n ratios = np.log(item / (bins - item))\\n \\n # Calculate the scores for each bin based on the ratios\\n scores = ratios * (bins - item)\\n \\n return scores\",\n \"objective\": 0.05081,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the square root of the bin's remaining capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the square root of the bin's remaining capacity\\n scores = (np.reciprocal(bins - item) * np.sqrt(bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score of a bin by subtracting the item size from the bin's rest capacity, dividing it by the difference between the bin's rest capacity and the maximum bin capacity, then adding 1 and finally taking the natural logarithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.log((bins - item) / (bins - max(bins))) + 1\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score defined as the product of the bin's capacity and the inverse of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the product of the bin's capacity and the inverse of its rest capacity\\n scores = np.array([bin_capacity * (1 / bin_rest_capacity) for bin_capacity, bin_rest_capacity in zip(bins, bins)])\\n \\n # Assign the item to the bin with the highest score\\n best_bin_index = np.argmax(scores)\\n best_bin_score = scores[best_bin_index]\\n \\n # Return the scores for all bins\\n return scores\",\n \"objective\": 0.05695,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each feasible bin as the sum of the inverse of the bin's rest capacity and the negative of item size squared multiplied by the square of the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = -np.square(item) * np.square(bins) / (bins + 1e-8)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity\\n scores = (np.reciprocal(np.abs(bins - item)) ** 0.5) / bins\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores for bins based on a power function of the ratio of item size to bin rest capacity, with the power being the ratio of the sum of bin rest capacities to total bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power function of the ratio of item size to bin rest capacity\\n power = (sum(bins) / len(bins)) ** (len(bins) - 1)\\n # Calculate the scores for each bin based on the power function\\n scores = np.power(item / bins, power)\\n # Return the scores\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the number of bins, scaled by the bin index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the number of bins, scaled by the bin index\\n scores = (bins / item) - (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the arithmetic mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average rest capacity and maximum capacity\\n avg_rest = np.mean(bins)\\n max_capacity = np.max(bins)\\n \\n # Apply a penalty to bins with more than half of the maximum capacity\\n penalties = np.where(bins > max_capacity / 2, 0.5 * (max_capacity - bins), 0)\\n \\n # Calculate the scores for each bin\\n scores = avg_rest + penalties\\n \\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index\\n scores = (np.reciprocal(bins - item) * np.cbrt(np.arange(len(bins))))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size, and using a logarithmic function to increase the penalty for using larger bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size\\n scores = (bins ** 2) / (bins - item)\\n \\n # Apply a logarithmic function to increase the penalty for using larger bins\\n scores = np.log(scores + 1)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the ratio of item size to each bin's rest capacity, and the product of the ratio and the rest capacity.\\n2. Calculate the score for each bin based on the ratio and the product.\\n3. Return the scores for the bins for assignment\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item size to each bin's rest capacity\\n ratios = np.divide(item, bins)\\n \\n # Calculate the product of the ratio and the rest capacity\\n products = np.multiply(ratios, bins)\\n \\n # Calculate the score for each bin based on the ratio and the product\\n scores = np.maximum(products, 0)\\n \\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the reciprocal of difference between the bin's capacity and item size and the square root of the bin's index, divided by the difference between maximum capacity and bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the reciprocal of difference between the bin's capacity and item size and the square root of the bin's index, divided by the difference between maximum capacity and bin's capacity\\n scores = (np.reciprocal(np.abs(bins - item)) ** 0.5) / (np.maximum(bins, item) - bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04638,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the exponent of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the exponent of the bin's index\\n scores = np.reciprocal(np.abs(bins - item)) ** (bins.argsort() + 1)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04679,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate bin score using the natural logarithm of the ratio of item size to the difference between bin rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic ratio of item size to bin rest capacity\\n ratios = np.log(item / (bins - item))\\n \\n # Calculate the scores for each bin based on the ratios\\n scores = ratios * (bins - item)\\n \\n return scores\",\n \"objective\": 0.05081,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each feasible bin as the sum of the inverse of the bin's rest capacity and the negative of item size squared multiplied by the square of the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = -np.square(item) * np.square(bins) / (bins + 1e-8)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity\\n scores = (np.reciprocal(np.abs(bins - item)) ** 0.5) / bins\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index\\n scores = (bins / item) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the arithmetic mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average rest capacity and maximum capacity\\n avg_rest = np.mean(bins)\\n max_capacity = np.max(bins)\\n \\n # Apply a penalty to bins with more than half of the maximum capacity\\n penalties = np.where(bins > max_capacity / 2, 0.5 * (max_capacity - bins), 0)\\n \\n # Calculate the scores for each bin\\n scores = avg_rest + penalties\\n \\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index\\n scores = (np.reciprocal(bins - item) * np.cbrt(np.arange(len(bins))))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size, and using a logarithmic function to increase the penalty for using larger bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size\\n scores = (bins ** 2) / (bins - item)\\n \\n # Apply a logarithmic function to increase the penalty for using larger bins\\n scores = np.log(scores + 1)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Create a score by taking the product of the reciprocal of the difference between the bin capacity and item size, the square of the bin's capacity, and the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin capacity and item size\\n r = np.reciprocal(np.subtract(bins, item))\\n \\n # Calculate the square of the bin's capacity\\n s = np.square(bins)\\n \\n # Calculate the inverse of the bin's index\\n i = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the final score\\n scores = r * s * i\\n \\n return scores\",\n \"objective\": 0.04467,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the ratio of item size to each bin's rest capacity, and the product of the ratio and the rest capacity.\\n2. Calculate the score for each bin based on the ratio and the product.\\n3. Return the scores for the bins for assignment\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item size to each bin's rest capacity\\n ratios = np.divide(item, bins)\\n \\n # Calculate the product of the ratio and the rest capacity\\n products = np.multiply(ratios, bins)\\n \\n # Calculate the score for each bin based on the ratio and the product\\n scores = np.maximum(products, 0)\\n \\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the sum of the reciprocal of difference between the bin's capacity and item size and the square root of the bin's index, divided by the difference between maximum capacity and bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the sum of the reciprocal of difference between the bin's capacity and item size and the square root of the bin's index, divided by the difference between maximum capacity and bin's capacity\\n scores = (np.reciprocal(np.abs(bins - item)) ** 0.5) / (np.maximum(bins, item) - bins)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04638,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the exponent of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the exponent of the bin's index\\n scores = np.reciprocal(np.abs(bins - item)) ** (bins.argsort() + 1)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04679,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each feasible bin as the sum of the inverse of the bin's rest capacity and the negative of item size squared multiplied by the square of the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = -np.square(item) * np.square(bins) / (bins + 1e-8)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and item size and the square root of the bin's index, divided by the bin's capacity\\n scores = (np.reciprocal(np.abs(bins - item)) ** 0.5) / bins\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + ((1 - bins) * (1 / (item - bins)))\\n \\n # Normalize the scores to ensure they add up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index\\n scores = (bins / item) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the arithmetic mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average rest capacity and maximum capacity\\n avg_rest = np.mean(bins)\\n max_capacity = np.max(bins)\\n \\n # Apply a penalty to bins with more than half of the maximum capacity\\n penalties = np.where(bins > max_capacity / 2, 0.5 * (max_capacity - bins), 0)\\n \\n # Calculate the scores for each bin\\n scores = avg_rest + penalties\\n \\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index\\n scores = (np.reciprocal(bins - item) * np.cbrt(np.arange(len(bins))))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size, and using a logarithmic function to increase the penalty for using larger bins. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the square of the bin's capacity multiplied by the inverse of the amount by which the bin's capacity exceeds the item size\\n scores = (bins ** 2) / (bins - item)\\n \\n # Apply a logarithmic function to increase the penalty for using larger bins\\n scores = np.log(scores + 1)\\n \\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Create a score by taking the product of the reciprocal of the difference between the bin capacity and item size, the square of the bin's capacity, and the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the difference between the bin capacity and item size\\n r = np.reciprocal(np.subtract(bins, item))\\n \\n # Calculate the square of the bin's capacity\\n s = np.square(bins)\\n \\n # Calculate the inverse of the bin's index\\n i = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the final score\\n scores = r * s * i\\n \\n return scores\",\n \"objective\": 0.04467,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n1. Calculate the ratio of item size to each bin's rest capacity, and the product of the ratio and the rest capacity.\\n2. Calculate the score for each bin based on the ratio and the product.\\n3. Return the scores for the bins for assignment\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item size to each bin's rest capacity\\n ratios = np.divide(item, bins)\\n \\n # Calculate the product of the ratio and the rest capacity\\n products = np.multiply(ratios, bins)\\n \\n # Calculate the score for each bin based on the ratio and the product\\n scores = np.maximum(products, 0)\\n \\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index\\n scores = -np.log(bins / item) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each feasible bin as the sum of the inverse of the bin's rest capacity and the negative of item size squared multiplied by the square of the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = -np.square(item) * np.square(bins) / (bins + 1e-8)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity; but in addition, if the rest capacity of the bin is less than or equal to half of its maximum capacity, the score is multiplied by a factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Multiply the score by 2 if the rest capacity of the bin is less than or equal to half of its maximum capacity\\n scores[bins <= (bins / 2)] *= 2\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of a bin as the product of the difference between its maximum and current capacity and the reciprocal of the capacity difference between the bin and the item, multiplied by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (bins - item) * (1 / (bins - item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + ((1 - bins) * (1 / (item - bins)))\\n \\n # Normalize the scores to ensure they add up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index\\n scores = (bins / item) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the arithmetic mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average rest capacity and maximum capacity\\n avg_rest = np.mean(bins)\\n max_capacity = np.max(bins)\\n \\n # Apply a penalty to bins with more than half of the maximum capacity\\n penalties = np.where(bins > max_capacity / 2, 0.5 * (max_capacity - bins), 0)\\n \\n # Calculate the scores for each bin\\n scores = avg_rest + penalties\\n \\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the cubic root of the bin's index\\n scores = (np.reciprocal(bins - item) * np.cbrt(np.arange(len(bins))))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index\\n scores = -np.log(bins / item) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity; but in addition, if the rest capacity of the bin is less than or equal to half of its maximum capacity, the score is multiplied by a factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Multiply the score by 2 if the rest capacity of the bin is less than or equal to half of its maximum capacity\\n scores[bins <= (bins / 2)] *= 2\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of a bin as the product of the difference between its maximum and current capacity and the reciprocal of the capacity difference between the bin and the item, multiplied by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (bins - item) * (1 / (bins - item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + ((1 - bins) * (1 / (item - bins)))\\n \\n # Normalize the scores to ensure they add up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index, scaled by the bin index\\n scores = (bins / item) - (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiply each bin's capacity by the square of the reciprocal of the bin's index, multiplied by the square root of the reciprocal of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the formula provided\\n scores = (bins * (np.sqrt(item) / bins)) ** 2\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Novel Algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the bin's index multiplied by the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * bins) / (item - bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size, where the weights are the bin's index or the inverse of the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of its rest capacity and the reciprocal of the difference between its capacity and the item size\\n scores = (bins * (1 - item / bins)) / (bins - item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the item size exceeds the bin's capacity, scaled by the log of the bin index\\n scores = -np.log(bins / item) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the inverse of the amount by which the bin's capacity exceeds the item size, scaled by the bin index\\n scores = (np.ones_like(bins) - (bins / item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the product of the reciprocal of the difference between the bin's capacity and the item size and the logarithm of the bin's index\\n scores = np.log(np.reciprocal(bins - item)) + np.log(np.arange(len(bins)))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin as the inverse of the item size multiplied by the square root of the product of the bin's capacity and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.sqrt(bins * item) - 1) / (np.sqrt(bins) - 1)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score of each bin as the product of the bin's capacity and the square root of the reciprocal of the difference between its capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = np.sqrt(np.reciprocal(bins - item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: For each bin, score is computed as a weighted sum of the exponential of rest capacity divided by item size and reciprocal of rest capacity, with weights inversely proportional to the square root of bin index and the rest capacity; if rest capacity is less than half of max capacity, multiply score by two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the weights for each bin\\n weights = np.sqrt(np.arange(len(bins)) + 1) / (bins * item)\\n \\n # Compute the scores for each bin\\n scores = np.exp(-weights * bins) / (bins * item)\\n \\n # Multiply the scores by two if the rest capacity is less than half of the max capacity\\n scores[bins < item / 2] *= 2\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity; but in addition, if the rest capacity of the bin is less than or equal to half of its maximum capacity, the score is multiplied by a factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + (item * (1 / (item - bins)))\\n \\n # Multiply the score by 2 if the rest capacity of the bin is less than or equal to half of its maximum capacity\\n scores[bins <= (bins / 2)] *= 2\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores as the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic product of the reciprocal of the difference between the bin's capacity and the item size and the bin's index raised to a power\\n scores = np.log(np.reciprocal(np.abs(bins - item))) ** (bins + 1)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores as the sum of the difference between maximum capacity and bin's capacity, divided by the difference between item size and maximum capacity, multiplied by the ratio of maximum capacity to bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (np.maximum(bins - item, 0) / (item - np.minimum(bins, item))) * (bins / np.maximum(bins, item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of a bin as the product of the difference between its maximum and current capacity and the reciprocal of the capacity difference between the bin and the item, multiplied by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (bins - item) * (1 / (bins - item)) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size, where the weights are the product of the inverse of the bin's index and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the weighted sum of the rest capacity and the reciprocal of the difference between the capacity and the item size\\n scores = (bins * (1 / (bins - item))) + ((1 - bins) * (1 / (item - bins)))\\n \\n # Normalize the scores to ensure they add up to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Re-calculate the score for each bin based on the item size, multiplying the score of a bin by the ratio of the item size to the remaining capacity to prioritize bins with more remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the remaining capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Prioritize bins with more remaining capacity\\n scores[bins == 0] = 0\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores as the difference between the bin's capacity divided by the item size and the bin index\\n scores = (bins / item) - np.arange(len(bins))\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Multiply each bin's capacity by the square of the reciprocal of the bin's index, multiplied by the square root of the reciprocal of the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the formula provided\\n scores = (bins * (np.sqrt(item) / bins)) ** 2\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score based on the geometric mean of the rest capacity and the maximum capacity, and apply a penalty to bins with more than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the geometric mean of the rest capacities and the maximum capacity\\n gmean = np.sqrt(np.prod(bins)) / np.sqrt(len(bins))\\n max_capacity = np.max(bins)\\n # Apply a penalty to bins with more than twice the item size\\n penalties = np.where(bins > 2 * item, 0.5, 0)\\n # Calculate the scores for each bin\\n scores = (gmean - penalties) / max_capacity\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Normalize the bin capacities to the item size, then calculate the score as the maximum value among all bins minus the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bin capacities to the item size\\n norm_bins = bins / item\\n \\n # Calculate the score for each bin\\n scores = np.maximum(norm_bins - item, 0)\\n \\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with lower rest capacity and higher index by calculating the score as the product of the rest capacity and the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = rest_capacities * reciprocal_positions\\n \\n return scores\",\n \"objective\": 0.04699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the rest capacity, using a weighted sum of rest capacity and inverse of bin number, then returns scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin based on the rest capacity\\n scores = (rest_capacities / np.maximum(rest_capacities, 1)) ** 0.5\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns a score to each bin based on the normalized bin capacity with a discount factor that exponentially decays with the bin order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacities\\n norm_capacities = bins / np.max(bins)\\n \\n # Calculate the discount factor\\n discount_factor = np.exp(-np.arange(len(norm_capacities)) * 0.5)\\n \\n # Calculate the scores for each bin\\n scores = (norm_capacities * discount_factor).cumsum()\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.06097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the rest capacity and a measure of the bin's position in the sequence.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the rest capacity and the bin's position in the sequence\\n scores = np.zeros(len(bins))\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity >= item:\\n scores[i] = (bin_capacity - item) / (len(bins) - i)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.11037,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin with the maximum score, where the score is calculated by dividing the remaining bin capacity by the item size and subtracting a penalty for bins with maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = (bins - item) / item\\n \\n # Subtract a penalty for bins with maximum capacity\\n scores[bins == max(bins)] -= 10\\n \\n return scores\",\n \"objective\": 0.13231,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a weight factor to penalize bins with maximum capacity and avoid using them. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = (bins - item) / (bins + item)\\n \\n # Penalize bins with maximum capacity and avoid using them\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.15605,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin using the item size divided by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the rest capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.square(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as a multiplication of the minimum rest capacity in the bins and the absolute difference between the maximum and the current bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum rest capacity in the bins\\n min_rest_capacity = np.min(bins) - item\\n \\n # Calculate the absolute difference between the maximum and current bin capacity\\n abs_diff = np.abs(np.max(bins) - bins)\\n \\n # Multiply the minimum rest capacity and absolute difference to get the scores\\n scores = min_rest_capacity * abs_diff\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the product of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (item / (bins * np.sqrt(np.arange(len(bins)) + 1)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then raise the value to the power of the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) ** (bins / item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin using the item size divided by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the rest capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.square(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as a multiplication of the minimum rest capacity in the bins and the absolute difference between the maximum and the current bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum rest capacity in the bins\\n min_rest_capacity = np.min(bins) - item\\n \\n # Calculate the absolute difference between the maximum and current bin capacity\\n abs_diff = np.abs(np.max(bins) - bins)\\n \\n # Multiply the minimum rest capacity and absolute difference to get the scores\\n scores = min_rest_capacity * abs_diff\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the product of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (item / (bins * np.sqrt(np.arange(len(bins)) + 1)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then raise the value to the power of the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) ** (bins / item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin using the item size divided by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the rest capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns bins by calculating the score as the item size divided by the sum of the cube root of the bin's position and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the bin's position and remaining capacity\\n scores = (item / (np.cbrt(np.arange(len(bins))) + np.cbrt(bins - item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the product of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (item / (bins * np.sqrt(np.arange(len(bins)) + 1)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then raise the value to the power of the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) ** (bins / item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns bins by calculating the score as the item size divided by the sum of the cube root of the bin's position and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the bin's position and remaining capacity\\n scores = (item / (np.cbrt(np.arange(len(bins))) + np.cbrt(bins - item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the product of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the formula you provided\\n scores = (item / (bins * np.sqrt(np.arange(len(bins)) + 1)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm will calculate the score of a bin by subtracting the division of the item's remainder after a division operation with the bin's capacity from 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.zeros(len(bins))\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity >= item:\\n scores[i] = 1 - (bin_capacity % item) / item\\n else:\\n scores[i] = 0\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are calculated by taking the difference between the item size and the square root of the bins' capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the square root of the bins' capacities\\n diff = np.sqrt(bins) - item\\n \\n # Calculate the scores for each bin based on the difference\\n scores = np.abs(diff)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns bins by calculating the score as the item size divided by the sum of the cube root of the bin's position and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the bin's position and remaining capacity\\n scores = (item / (np.cbrt(np.arange(len(bins))) + np.cbrt(bins - item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm will calculate the score of a bin by subtracting the division of the item's remainder after a division operation with the bin's capacity from 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.zeros(len(bins))\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity >= item:\\n scores[i] = 1 - (bin_capacity % item) / item\\n else:\\n scores[i] = 0\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are calculated by taking the difference between the item size and the square root of the bins' capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the square root of the bins' capacities\\n diff = np.sqrt(bins) - item\\n \\n # Calculate the scores for each bin based on the difference\\n scores = np.abs(diff)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns bins by calculating the score as the item size divided by the sum of the cube root of the bin's position and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the bin's position and remaining capacity\\n scores = (item / (np.cbrt(np.arange(len(bins))) + np.cbrt(bins - item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are calculated by taking the difference between the item size and the square root of the bins' capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the square root of the bins' capacities\\n diff = np.sqrt(bins) - item\\n \\n # Calculate the scores for each bin based on the difference\\n scores = np.abs(diff)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns bins by calculating the score as the item size divided by the sum of the cube root of the bin's position and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the bin's position and remaining capacity\\n scores = (item / (np.cbrt(np.arange(len(bins))) + np.cbrt(bins - item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Scores are calculated by taking the difference between the item size and the square root of the bins' capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item size and the square root of the bins' capacities\\n diff = np.sqrt(bins) - item\\n \\n # Calculate the scores for each bin based on the difference\\n scores = np.abs(diff)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns bins by calculating the score as the item size divided by the sum of the cube root of the bin's position and the cube root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the bin's position and remaining capacity\\n scores = (item / (np.cbrt(np.arange(len(bins))) + np.cbrt(bins - item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the square root of the bins' capacities and the item size\\n diff = np.abs(np.sqrt(bins) - item)\\n \\n # Divide the absolute difference by the item size\\n scores = diff / item\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the square root of the bins' capacities and the item size\\n diff = np.abs(np.sqrt(bins) - item)\\n \\n # Divide the absolute difference by the item size\\n scores = diff / item\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculating the score as the reciprocal of the product of the rest capacity and the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the product of the rest capacity and the bin's position\\n scores = 1 / (bins * item)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the normalized bin capacity and the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacity and the inverse of the bin number\\n norm_capacity = bins / np.sum(bins)\\n inv_bin_num = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin based on the normalized capacity and the inverse of the bin number\\n scores = norm_capacity * inv_bin_num\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a weighted sum of the bin's relative capacity, number of items in the bin, and inverse of bin number, using a customizable weight vector.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weights for each bin based on its relative capacity, number of items, and inverse of bin number\\n weights = np.array([bin_capacity / (bin_number + 1) for bin_number, bin_capacity in enumerate(bins)])\\n \\n # Calculate the scores for each bin based on the weights and the item size\\n scores = np.dot(weights, item)\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Normalize the bin capacities to the item size, then calculate the score as the maximum value among all bins minus the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bin capacities to the item size\\n norm_bins = bins / item\\n \\n # Calculate the score for each bin\\n scores = np.maximum(norm_bins - item, 0)\\n \\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with lower rest capacity and higher index by calculating the score as the product of the rest capacity and the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = rest_capacities * reciprocal_positions\\n \\n return scores\",\n \"objective\": 0.04699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the rest capacity, using a weighted sum of rest capacity and inverse of bin number, then returns scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin based on the rest capacity\\n scores = (rest_capacities / np.maximum(rest_capacities, 1)) ** 0.5\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns a score to each bin based on the normalized bin capacity with a discount factor that exponentially decays with the bin order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacities\\n norm_capacities = bins / np.max(bins)\\n \\n # Calculate the discount factor\\n discount_factor = np.exp(-np.arange(len(norm_capacities)) * 0.5)\\n \\n # Calculate the scores for each bin\\n scores = (norm_capacities * discount_factor).cumsum()\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.06097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the remaining capacity and the reciprocal of the bin's position, then multiplying the result by a penalty for bins with maximum capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the remaining capacity and the reciprocal of the bin's position\\n scores = (bins - item) / (np.arange(len(bins)) + 1)\\n \\n # Multiply the scores by a penalty for bins with maximum capacity to minimize the number of used bins\\n max_capacity = np.max(bins)\\n penalties = np.where(bins == max_capacity, 0, 1)\\n scores *= penalties\\n \\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns scores based on the bin capacity raised to a power, which grows with the bin order, and a discount factor that decreases exponentially.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of the bin capacity\\n powers = np.power(bins, np.arange(len(bins)))\\n \\n # Calculate the discount factor\\n discount_factor = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Calculate the scores\\n scores = powers * discount_factor\\n \\n return scores\",\n \"objective\": 0.06691,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores based on the remaining capacity and the reciprocal of the bin's position, multiplying the result by a penalty for bins with maximum capacity and a bonus for bins with minimum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on the remaining capacity and the reciprocal of the bin's position\\n scores = (bins - item) / (np.arange(len(bins)) + 1)\\n \\n # Apply a penalty for bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] *= 0.5\\n \\n # Apply a bonus for bins with minimum capacity\\n min_capacity = np.min(bins)\\n scores[bins == min_capacity] *= 1.5\\n \\n return scores\",\n \"objective\": 0.07526,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on capacity difference with penalties proportional to item size for bins at maximum capacity multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the capacity difference between each bin and the item size\\n diff = np.abs(bins - item)\\n \\n # Calculate the penalty for using a full bin\\n penalty = np.where(diff == 0, 0, (diff / item) * (1 - bins))\\n \\n # Calculate the total score for each bin\\n scores = diff + penalty\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the square root of the bins' capacities and the item size\\n diff = np.abs(np.sqrt(bins) - item)\\n \\n # Divide the absolute difference by the item size\\n scores = diff / item\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the remaining capacity, the number of items that can fit in the bin, the penalty for bins with maximum capacity, and an additional penalty for bins that are close to full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = (remaining_capacity == 0) * 100\\n \\n # Calculate the penalty for bins that are close to full\\n near_full_penalty = (num_items_per_bin > 0.95) * 100\\n \\n # Calculate the total score for each bin\\n scores = remaining_capacity + num_items_per_bin + max_capacity_penalty + near_full_penalty\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of a bin by subtracting the square of the difference between the bin's capacity and the item's size from the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between its capacity and the item's size\\n scores = np.subtract(bins, np.square(np.subtract(bins, item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the square root of the bins' capacities and the item size\\n diff = np.abs(np.sqrt(bins) - item)\\n \\n # Divide the absolute difference by the item size\\n scores = diff / item\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the remaining capacity, the number of items that can fit in the bin, the penalty for bins with maximum capacity, and an additional penalty for bins that are close to full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = (remaining_capacity == 0) * 100\\n \\n # Calculate the penalty for bins that are close to full\\n near_full_penalty = (num_items_per_bin > 0.95) * 100\\n \\n # Calculate the total score for each bin\\n scores = remaining_capacity + num_items_per_bin + max_capacity_penalty + near_full_penalty\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of a bin by subtracting the square of the difference between the bin's capacity and the item's size from the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between its capacity and the item's size\\n scores = np.subtract(bins, np.square(np.subtract(bins, item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the square root of the bins' capacities and the item size\\n diff = np.abs(np.sqrt(bins) - item)\\n \\n # Divide the absolute difference by the item size\\n scores = diff / item\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the remaining capacity, the number of items that can fit in the bin, the penalty for bins with maximum capacity, and an additional penalty for bins that are close to full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = (remaining_capacity == 0) * 100\\n \\n # Calculate the penalty for bins that are close to full\\n near_full_penalty = (num_items_per_bin > 0.95) * 100\\n \\n # Calculate the total score for each bin\\n scores = remaining_capacity + num_items_per_bin + max_capacity_penalty + near_full_penalty\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of a bin by subtracting the square of the difference between the bin's capacity and the item's size from the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between its capacity and the item's size\\n scores = np.subtract(bins, np.square(np.subtract(bins, item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the square root of the bins' capacities and the item size\\n diff = np.abs(np.sqrt(bins) - item)\\n \\n # Divide the absolute difference by the item size\\n scores = diff / item\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the remaining capacity, the number of items that can fit in the bin, the penalty for bins with maximum capacity, and an additional penalty for bins that are close to full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = (remaining_capacity == 0) * 100\\n \\n # Calculate the penalty for bins that are close to full\\n near_full_penalty = (num_items_per_bin > 0.95) * 100\\n \\n # Calculate the total score for each bin\\n scores = remaining_capacity + num_items_per_bin + max_capacity_penalty + near_full_penalty\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of a bin by subtracting the square of the difference between the bin's capacity and the item's size from the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between its capacity and the item's size\\n scores = np.subtract(bins, np.square(np.subtract(bins, item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the square root of the bins' capacities and the item size\\n diff = np.abs(np.sqrt(bins) - item)\\n \\n # Divide the absolute difference by the item size\\n scores = diff / item\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the score by subtracting the item size from the rest capacity and dividing it by the product of the item size and the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = (bins - item) / (item * (bins - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"Score bins based on the weighted sum of the remaining capacity and the number of items that can fit in the bin, with a penalty for bins that have been used recently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins that have been used recently\\n recent_penalty = np.where(remaining_capacity < item, 0, 1)\\n \\n # Calculate the total score for each bin\\n scores = (num_items_per_bin * remaining_capacity) + recent_penalty\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on a weighted sum of the remaining capacity, the square of the number of items that can fit in the bin, the penalty for bins with maximum capacity, and an additional penalty for bins that are close to full. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the square of the number of items that can fit in each bin\\n num_items_in_bin = np.minimum(remaining_capacity, item)\\n num_items_squared = num_items_in_bin ** 2\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = np.where(bins == item, 0, 1)\\n \\n # Calculate the additional penalty for bins that are close to full\\n near_full_penalty = np.where(np.abs(remaining_capacity - item) < 0.5 * item, 0, 1)\\n \\n # Combine the penalties and calculate the total score for each bin\\n scores = (num_items_squared + max_capacity_penalty + near_full_penalty) / (remaining_capacity + 1e-8)\\n \\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on a weighted sum of the remaining capacity, the number of items that can fit in the bin, and the number of empty neighboring bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = np.floor(remaining_capacity / item)\\n \\n # Calculate the number of empty neighboring bins\\n num_empty_neighboring_bins = np.sum(np.where(remaining_capacity == 0, 1, 0))\\n \\n # Calculate the score for each bin\\n scores = (num_items_per_bin + num_empty_neighboring_bins) / remaining_capacity\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on a weighted sum of the remaining capacity, the number of items that can fit in the bin, the penalty for bins with maximum capacity, and an additional penalty for bins that are close to full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = (remaining_capacity == 0) * 100\\n \\n # Calculate the penalty for bins that are close to full\\n near_full_penalty = (num_items_per_bin > 0.95) * 100\\n \\n # Calculate the total score for each bin\\n scores = remaining_capacity + num_items_per_bin + max_capacity_penalty + near_full_penalty\\n \\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin by subtracting the remainder of the division between the item's size by the bin's capacity from the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item's size and the bin's capacity\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = item - (bins[i] % item)\\n else:\\n scores[i] = 0\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Normalize the bins' positions and remaining capacities to be between 0 and 1, and define the bin score as the sum of the exponential of the normalized bin position divided by the item size and the exponential of the normalized bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bins' positions and remaining capacities to be between 0 and 1\\n norm_positions = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n norm_remaining_capacities = (bins - item) / (np.max(bins) - np.min(bins))\\n \\n # Calculate the scores for each bin\\n scores = np.exp(-norm_positions * item) / np.exp(-norm_remaining_capacities * item)\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My algorithm calculates the score of a bin by subtracting the difference between the item size and the bin's capacity from the division of the item size by the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item - bins) / (bins + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by subtracting the difference of multiplying the item's size and its square root by its square root from the result of adding the item's size and square root of itself\\n scores = np.sqrt(np.abs(item - np.sqrt(np.abs(item * np.sqrt(bins) - np.sqrt(bins)))))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a score for bins as the weighted sum of the item reciprocal and the reciprocal of the bin's position, while considering the bin's remaining capacity and the item's weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item weight\\n item_reciprocal = 1 / item\\n \\n # Initialize the scores array\\n scores = np.zeros(len(bins))\\n \\n # Iterate over the bins\\n for i, bin in enumerate(bins):\\n # Calculate the reciprocal of the bin's position\\n bin_reciprocal = 1 / (i + 1)\\n \\n # Calculate the score for this bin\\n score = item_reciprocal * bin_reciprocal\\n \\n # Check if the bin has remaining capacity\\n if bin > 0:\\n # Calculate the reciprocal of the bin's remaining capacity\\n bin_remaining_capacity_reciprocal = 1 / (bin - item)\\n \\n # Add the score for this bin based on its remaining capacity\\n score += item_reciprocal * bin_remaining_capacity_reciprocal\\n \\n # Store the score for this bin\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score of a bin by subtracting the square of the difference between the bin's capacity and the item's size from the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between its capacity and the item's size\\n scores = np.subtract(bins, np.square(np.subtract(bins, item)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate scores using the absolute difference between the square root of the bins' capacities plus a random constant and the item size, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the absolute difference between the square root of the bin capacity and the item size\\n scores = np.abs(np.sqrt(bins) - item) / item\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: New algorithm: Calculating the score as the reciprocal of the sum of the rest capacity and the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the sum of the rest capacity and the bin's position\\n scores = 1 / (bins + item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and a penalty for bins with maximum capacity while considering the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the bin positions\\n sqrt_positions = np.sqrt(np.arange(len(bins)))\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = np.where(bins == 0, 0, 1)\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) + (sqrt_positions * max_capacity_penalty)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and no penalty for bins with maximum capacity while considering the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) * reciprocal_positions\\n \\n # Mask out the scores for bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the normalized bin capacity and the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacity and the inverse of the bin number\\n norm_capacity = bins / np.sum(bins)\\n inv_bin_num = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin based on the normalized capacity and the inverse of the bin number\\n scores = norm_capacity * inv_bin_num\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the product of rest capacity and an index function that is inversely proportional to the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin position\\n inv_pos = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin\\n scores = item * inv_pos * bins\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the product of the normalized bin capacity and the inverse of the bin number, with a discount factor that exponentially decays with the bin order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacities\\n norm_capacities = bins / np.max(bins)\\n \\n # Calculate the inverse of the bin numbers\\n inv_bin_nums = np.arange(len(bins))[::-1]\\n \\n # Calculate the discount factor\\n discount_factor = np.exp(-inv_bin_nums * 0.5)\\n \\n # Calculate the scores for each bin\\n scores = (norm_capacities * discount_factor) ** item\\n \\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Normalize the bin capacities to the item size, then calculate the score as the maximum value among all bins minus the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bin capacities to the item size\\n norm_bins = bins / item\\n \\n # Calculate the score for each bin\\n scores = np.maximum(norm_bins - item, 0)\\n \\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with lower rest capacity and higher index by calculating the score as the product of the rest capacity and the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = rest_capacities * reciprocal_positions\\n \\n return scores\",\n \"objective\": 0.04699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on the ratio of bin capacity to the sum of all bins' capacities, weighted by the inverse of the bin's distance from the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of bin capacity to the sum of all bins' capacities\\n capacity_ratio = bins / np.sum(bins)\\n \\n # Calculate the distance of each bin from the middle of the array\\n middle_index = len(bins) // 2\\n distances = np.abs(np.arange(len(bins)) - middle_index)\\n \\n # Weight the capacity ratio by the inverse of the distance from the middle\\n weights = 1 / (distances + 1)\\n \\n # Calculate the scores for each bin using the weighted capacity ratio\\n scores = capacity_ratio * weights\\n \\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the rest capacity, using a weighted sum of rest capacity and inverse of bin number, then returns scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin based on the rest capacity\\n scores = (rest_capacities / np.maximum(rest_capacities, 1)) ** 0.5\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the sum of the bin's number of items divided by its maximum capacity, weighted by the item size and bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin as the sum of the bin's number of items divided by its maximum capacity, weighted by the item size and bin number\\n scores = (bins / bins.max()) * (item / bins)\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.05644,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: New algorithm: Calculating the score as the reciprocal of the sum of the rest capacity and the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the sum of the rest capacity and the bin's position\\n scores = 1 / (bins + item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and a penalty for bins with maximum capacity while considering the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the bin positions\\n sqrt_positions = np.sqrt(np.arange(len(bins)))\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = np.where(bins == 0, 0, 1)\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) + (sqrt_positions * max_capacity_penalty)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and no penalty for bins with maximum capacity while considering the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) * reciprocal_positions\\n \\n # Mask out the scores for bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the normalized bin capacity and the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacity and the inverse of the bin number\\n norm_capacity = bins / np.sum(bins)\\n inv_bin_num = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin based on the normalized capacity and the inverse of the bin number\\n scores = norm_capacity * inv_bin_num\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign scores to bins based on the reciprocal of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the remaining capacity for each bin\\n rc = np.reciprocal(bins - item)\\n \\n # Calculate the positional weight for each bin\\n pw = np.arange(len(bins)) / len(bins)\\n \\n # Combine the reciprocal of the remaining capacity and the positional weight\\n scores = rc * pw\\n \\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the product of rest capacity and an index function that is inversely proportional to the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin position\\n inv_pos = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin\\n scores = item * inv_pos * bins\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the product of the normalized bin capacity and the inverse of the bin number, with a discount factor that exponentially decays with the bin order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacities\\n norm_capacities = bins / np.max(bins)\\n \\n # Calculate the inverse of the bin numbers\\n inv_bin_nums = np.arange(len(bins))[::-1]\\n \\n # Calculate the discount factor\\n discount_factor = np.exp(-inv_bin_nums * 0.5)\\n \\n # Calculate the scores for each bin\\n scores = (norm_capacities * discount_factor) ** item\\n \\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Normalize the bin capacities to the item size, then calculate the score as the maximum value among all bins minus the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Normalize the bin capacities to the item size\\n norm_bins = bins / item\\n \\n # Calculate the score for each bin\\n scores = np.maximum(norm_bins - item, 0)\\n \\n return scores\",\n \"objective\": 0.04507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizing bins with lower rest capacity and higher index by calculating the score as the product of the rest capacity and the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = rest_capacities * reciprocal_positions\\n \\n return scores\",\n \"objective\": 0.04699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores based on the ratio of bin capacity to the sum of all bins' capacities, weighted by the inverse of the bin's distance from the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of bin capacity to the sum of all bins' capacities\\n capacity_ratio = bins / np.sum(bins)\\n \\n # Calculate the distance of each bin from the middle of the array\\n middle_index = len(bins) // 2\\n distances = np.abs(np.arange(len(bins)) - middle_index)\\n \\n # Weight the capacity ratio by the inverse of the distance from the middle\\n weights = 1 / (distances + 1)\\n \\n # Calculate the scores for each bin using the weighted capacity ratio\\n scores = capacity_ratio * weights\\n \\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the rest capacity, using a weighted sum of rest capacity and inverse of bin number, then returns scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin based on the rest capacity\\n scores = (rest_capacities / np.maximum(rest_capacities, 1)) ** 0.5\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: New algorithm: Calculating the score as the reciprocal of the sum of the rest capacity and the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the sum of the rest capacity and the bin's position\\n scores = 1 / (bins + item)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and a penalty for bins with maximum capacity while considering the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the bin positions\\n sqrt_positions = np.sqrt(np.arange(len(bins)))\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = np.where(bins == 0, 0, 1)\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) + (sqrt_positions * max_capacity_penalty)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.square(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function to calculate the scores for each candidate bin based on the item size and the bin's current usage percentage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and the bin's current usage percentage\\n scores = (bins - item) / (bins * (1 - (item / bins)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and no penalty for bins with maximum capacity while considering the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) * reciprocal_positions\\n \\n # Mask out the scores for bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the normalized bin capacity and the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacity and the inverse of the bin number\\n norm_capacity = bins / np.sum(bins)\\n inv_bin_num = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin based on the normalized capacity and the inverse of the bin number\\n scores = norm_capacity * inv_bin_num\\n \\n # Return the scores for each bin\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign scores to bins based on the reciprocal of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the remaining capacity for each bin\\n rc = np.reciprocal(bins - item)\\n \\n # Calculate the positional weight for each bin\\n pw = np.arange(len(bins)) / len(bins)\\n \\n # Combine the reciprocal of the remaining capacity and the positional weight\\n scores = rc * pw\\n \\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the product of rest capacity and an index function that is inversely proportional to the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin position\\n inv_pos = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin\\n scores = item * inv_pos * bins\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the product of the normalized bin capacity and the inverse of the bin number, with a discount factor that exponentially decays with the bin order.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacities\\n norm_capacities = bins / np.max(bins)\\n \\n # Calculate the inverse of the bin numbers\\n inv_bin_nums = np.arange(len(bins))[::-1]\\n \\n # Calculate the discount factor\\n discount_factor = np.exp(-inv_bin_nums * 0.5)\\n \\n # Calculate the scores for each bin\\n scores = (norm_capacities * discount_factor) ** item\\n \\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and a penalty for bins with maximum capacity while considering the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the bin positions\\n sqrt_positions = np.sqrt(np.arange(len(bins)))\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = np.where(bins == 0, 0, 1)\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) + (sqrt_positions * max_capacity_penalty)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.square(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function to calculate the scores for each candidate bin based on the item size and the bin's current usage percentage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and the bin's current usage percentage\\n scores = (bins - item) / (bins * (1 - (item / bins)))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and no penalty for bins with maximum capacity while considering the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) * reciprocal_positions\\n \\n # Mask out the scores for bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Calculate the score as the product of the normalized bin capacity and the reciprocal of the sum of the bin's position and a constant. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacity\\n norm_capacity = bins / np.sum(bins)\\n \\n # Calculate the reciprocal of the sum of the bin's position and a constant\\n reciprocal = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the scores for each bin\\n scores = norm_capacity * reciprocal\\n \\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign scores to bins based on the reciprocal of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the remaining capacity for each bin\\n rc = np.reciprocal(bins - item)\\n \\n # Calculate the positional weight for each bin\\n pw = np.arange(len(bins)) / len(bins)\\n \\n # Combine the reciprocal of the remaining capacity and the positional weight\\n scores = rc * pw\\n \\n return scores\",\n \"objective\": 0.04397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate a score for each bin based on the product of rest capacity and an index function that is inversely proportional to the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the bin position\\n inv_pos = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the score for each bin\\n scores = item * inv_pos * bins\\n \\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and a penalty for bins with maximum capacity while considering the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the bin positions\\n sqrt_positions = np.sqrt(np.arange(len(bins)))\\n \\n # Calculate the penalty for bins with maximum capacity\\n max_capacity_penalty = np.where(bins == 0, 0, 1)\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) + (sqrt_positions * max_capacity_penalty)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.square(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as a multiplication of the minimum rest capacity in the bins and the absolute difference between the maximum and the current bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum rest capacity in the bins\\n min_rest_capacity = np.min(bins) - item\\n \\n # Calculate the absolute difference between the maximum and current bin capacity\\n abs_diff = np.abs(np.max(bins) - bins)\\n \\n # Multiply the minimum rest capacity and absolute difference to get the scores\\n scores = min_rest_capacity * abs_diff\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then raise the value to the power of the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) ** (bins / item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the maximum score to bins with sufficient remaining capacity and no penalty for bins with maximum capacity while considering the reciprocal of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the bin positions\\n reciprocal_positions = np.reciprocal(np.arange(len(bins)))\\n \\n # Calculate the scores for each bin\\n scores = (item / bins) * reciprocal_positions\\n \\n # Mask out the scores for bins with maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Calculate the score as the product of the normalized bin capacity and the reciprocal of the sum of the bin's position and a constant. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized bin capacity\\n norm_capacity = bins / np.sum(bins)\\n \\n # Calculate the reciprocal of the sum of the bin's position and a constant\\n reciprocal = 1 / (np.arange(len(bins)) + 1)\\n \\n # Calculate the scores for each bin\\n scores = norm_capacity * reciprocal\\n \\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin using the item size divided by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the rest capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.square(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as a multiplication of the minimum rest capacity in the bins and the absolute difference between the maximum and the current bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum rest capacity in the bins\\n min_rest_capacity = np.min(bins) - item\\n \\n # Calculate the absolute difference between the maximum and current bin capacity\\n abs_diff = np.abs(np.max(bins) - bins)\\n \\n # Multiply the minimum rest capacity and absolute difference to get the scores\\n scores = min_rest_capacity * abs_diff\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then raise the value to the power of the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) ** (bins / item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \" Score bins based on the sum of the remaining capacity and the number of items that can fit in the bin, with a bias towards bins that have recently been used. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity for each bin\\n remaining_capacity = bins - item\\n \\n # Calculate the number of items that can fit in each bin\\n num_items_per_bin = item / remaining_capacity\\n \\n # Calculate the score for each bin based on the remaining capacity and the number of items that can fit in it\\n scores = remaining_capacity * num_items_per_bin\\n \\n # Add a bias towards bins that have recently been used\\n scores += (np.random.rand(len(bins)) < 0.5) * 0.5\\n \\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the harmonic mean of the rest capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the harmonic mean of the rest capacities\\n rest_capacities = np.array([bin - item for bin in bins])\\n harmonic_mean = np.sum(rest_capacities) / np.prod(rest_capacities)\\n \\n # Calculate the score for each bin\\n scores = harmonic_mean * (bins - item)\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then divide the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) / (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by combining the normalized inverse of the remaining capacity and the penalized inverse of the bin number to maximize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized inverse of the remaining capacity\\n inv_remaining = 1 / (bins - item)\\n # Calculate the penalized inverse of the bin number\\n inv_penalized = 1 / (np.arange(len(bins)) + 1)\\n # Combine the two terms to get the final score\\n scores = inv_remaining * inv_penalized\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score to bins as the sum of item reciprocal and reciprocal of the bin position while considering the reciprocal of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the item size and the bin positions\\n item_recip = 1 / item\\n bin_positions = np.arange(len(bins)) + 1\\n bin_recips = 1 / bin_positions\\n \\n # Calculate the scores for each bin\\n scores = item_recip * bin_recips\\n \\n # Add the reciprocal of the bin remaining capacity to the scores\\n scores += 1 / (bins - item)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of the remaining capacity and the reciprocal of the number of items that can fit in the bin, with a bias towards bins that have recently been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of the number of items that can fit in each bin\\n num_items = np.array([bin_size - item for bin_size in bins])\\n reciprocal_num_items = 1 / num_items\\n \\n # Calculate the product of the remaining capacity and the reciprocal of the number of items that can fit in each bin\\n scores = np.multiply(bins, reciprocal_num_items)\\n \\n # Add a bias towards bins that have recently been used\\n recent_usage = np.random.randint(0, 10, len(bins))\\n scores += recent_usage * 0.5\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Define a score for each bin as the sum of the exponential of the bin position divided by the item size and the exponential of the bin's remaining capacity multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item size\\n scores = np.exp(-(bins / item) * (bins - item))\\n \\n # Add a constant term to the scores to make them more stable\\n scores += 0.5\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the item to bin ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) * (bins - item)\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin using the item size divided by the sum of the rest capacity and the square root of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and the rest capacity\\n scores = (item / (bins + np.sqrt(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate score as power of the exponential of the rest capacity, penalized by the number of bins already in use.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the rest capacity\\n exp_rest_capacity = np.exp(-bins)\\n \\n # Penalize the number of bins already in use\\n num_used_bins = len(np.where(bins > 0)[0])\\n penalty = num_used_bins ** 2\\n \\n # Calculate the score for each bin\\n scores = exp_rest_capacity - penalty\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates the score of a bin by dividing the item size by the sum of the rest capacity and the square of the bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (item / (bins + np.square(np.arange(len(bins)))))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm uses a score function that multiplies the item size with the rest capacity and subtracts it from a random constant to calculate the scores for each candidate bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and rest capacity\\n scores = (item * bins) - (np.random.randint(0, 100) * bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as a multiplication of the minimum rest capacity in the bins and the absolute difference between the maximum and the current bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the minimum rest capacity in the bins\\n min_rest_capacity = np.min(bins) - item\\n \\n # Calculate the absolute difference between the maximum and current bin capacity\\n abs_diff = np.abs(np.max(bins) - bins)\\n \\n # Multiply the minimum rest capacity and absolute difference to get the scores\\n scores = min_rest_capacity * abs_diff\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Scores bins based on the logarithmic difference between the item size and the bins' rest capacity, multiplied by the number of bins minus the current bin's position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic difference between the item size and the bins' rest capacities\\n diff = np.log(bins / item)\\n \\n # Calculate the number of bins minus the current bin's position\\n pos = np.arange(len(bins))\\n num_bins = len(bins)\\n diff -= (num_bins - pos)\\n \\n # Multiply the logarithmic difference by the number of bins minus the current bin's position\\n scores = diff * (num_bins - pos)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the item size with the rest capacity, and subtracting it from a constant, and then returns the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item * bins) - (item * bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then multiple the value by the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to bins based on the product of the remaining capacity and a positional weight that increases for bins closer to the middle of the array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the positional weights\\n weights = np.arange(len(bins)) / len(bins)\\n \\n # Calculate the scores\\n scores = (weights * bins) + (item - bins)\\n \\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: compute the score by subtracting the current used percentage from 1, and then raise the value to the power of the difference between this value and the rest capacity to item ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the score for each bin\\n scores = (1 - (bins / item)) ** (bins / item)\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm considers the rest capacity of each bin in relation to the item's size, calculates the ratio of the item's size to the bin's rest capacity, and normalizes the scores based on the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item's size to the bin's rest capacity\\n ratios = item / (bins - item)\\n \\n # Normalize the scores based on the item's size\\n scores = ratios / np.max(ratios)\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin based on the sum of the bin's rest capacity divided by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Calculate the sum of the bin's rest capacity divided by the power of 2\\n scores = (bins - item) / powers\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Adjusted algorithm: Calculates bin scores as the weighted sum of the rest capacity to the power of 0.5, the proximity to the item size, and a penalty for exceeding the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity to the power of 0.5, the proximity to the item size, and a penalty for exceeding the maximum capacity\\n scores = (bins / np.sqrt(bins)) * (np.abs(item - bins) ** 0.5) + (bins > item) * (bins - item)\\n \\n # Penalize bins that exceed the maximum capacity\\n scores[bins > item] -= (bins[bins > item] - item) ** 2\\n \\n return scores\",\n \"objective\": 0.04568,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores bins as a product of their rest capacity and the inverse of the maximum score of all bins, with bins at maximum capacity receiving a score of zero and prioritizing larger rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_scores = np.maximum(0, bins - item)\\n \\n # Calculate the inverse of the maximum score for each bin\\n inv_max_scores = np.reciprocal(max_scores)\\n \\n # Calculate the product of the rest capacity and the inverse of the maximum score for each bin\\n scores = np.multiply(bins, inv_max_scores)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0492,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores bins by combining the percentage of rest capacity and the inverse of the difference between the item size and the rest capacity, prioritizing bins with higher percentages and lower differences.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the percentage of rest capacity for each bin\\n rest_capacities = bins - item\\n percents = rest_capacities / bins * 100\\n \\n # Calculate the inverse of the difference between the item size and the rest capacity\\n diffs = item - rest_capacities\\n inv_diffs = 1 / (diffs + 1e-6)\\n \\n # Combine the percentage of rest capacity and the inverse of the difference\\n scores = percents * inv_diffs\\n \\n return scores\",\n \"objective\": 0.11671,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Score bins based on their remaining capacities relative to the item's size, with a penalty for bins that have reached their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its remaining capacity and the item's size\\n scores = (bins - item) / (bins + item)\\n \\n # Penalize bins that have reached their maximum capacity\\n max_capacity = np.max(bins)\\n scores[bins >= max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.15605,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Design a novel score function that subtracts the ratio of the item size to the bin's rest capacity from one and raises the result to a power.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the bin's rest capacity\\n ratios = item / (bins - item)\\n \\n # Subtract 1 from the ratio and raise it to the power of 0.5\\n scores = (ratios - 1) ** 0.5\\n \\n return scores\",\n \"objective\": 0.19952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Adjusted algorithm: Calculates bin scores as the weighted sum of the rest capacity, the proximity to the item size, and a penalty for exceeding the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacities = bins - item\\n \\n # Calculate the proximity to the item size for each bin\\n proximities = np.abs(rest_capacities - item)\\n \\n # Calculate the penalty for exceeding the maximum capacity for each bin\\n penalties = np.where(rest_capacities > item, rest_capacities - item, 0)\\n \\n # Calculate the total score for each bin\\n scores = (rest_capacities * proximities + penalties) / (rest_capacities + 1)\\n \\n return scores\",\n \"objective\": 0.40658,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / (bins * (1 - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score function for bins is calculated as the inverse exponential decay of the difference between rest capacity and item size, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse exponential decay of the difference between rest capacity and item size\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New score function: Calculate the score as the absolute difference between the logarithmic rest capacity and the bin index, multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins - item)\\n \\n # Calculate the absolute difference between the logarithmic rest capacity and the bin index\\n abs_diff = np.abs(np.arange(len(bins)) - log_rest_capacity)\\n \\n # Multiply the absolute difference by a constant\\n scores = abs_diff * 0.5\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the rest capacity and the product of the item and the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities * (1 / np.exp(-np.arange(len(rest_capacities)) ** 2))\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the rest capacity and an increasing linear function of the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities + (np.arange(len(rest_capacities)) + 1) * item\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the item size by the percentage of the bin's capacity that is greater than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item / bins) - (bins ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score function for bins is calculated as the inverse exponential decay of the difference between rest capacity and item size, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse exponential decay of the difference between rest capacity and item size\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New score function: Calculate the score as the absolute difference between the logarithmic rest capacity and the bin index, multiplied by a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins - item)\\n \\n # Calculate the absolute difference between the logarithmic rest capacity and the bin index\\n abs_diff = np.abs(np.arange(len(bins)) - log_rest_capacity)\\n \\n # Multiply the absolute difference by a constant\\n scores = abs_diff * 0.5\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the rest capacity and the product of the item and the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities * (1 / np.exp(-np.arange(len(rest_capacities)) ** 2))\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the rest capacity and an increasing linear function of the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities + (np.arange(len(rest_capacities)) + 1) * item\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the item size by the percentage of the bin's capacity that is greater than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item / bins) - (bins ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score function for bins is calculated as the inverse exponential decay of the difference between rest capacity and item size, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse exponential decay of the difference between rest capacity and item size\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by multiplying their index by a weight, subtracting their capacity from the result, and adding a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weights for each bin based on its index\\n weights = np.arange(len(bins)) * 0.5\\n \\n # Subtract the capacity of each bin from the weighted sum\\n scores = (weights - bins) + 10\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Score bins by subtracting the item size from half the bin capacity and dividing by the absolute difference between the half bin capacity and item size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / abs(bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the rest capacity and an increasing linear function of the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities + (np.arange(len(rest_capacities)) + 1) * item\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the item size by the percentage of the bin's capacity that is greater than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item / bins) - (bins ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by multiplying their index by a weight, subtracting their capacity from the result, and adding a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weights for each bin based on its index\\n weights = np.arange(len(bins)) * 0.5\\n \\n # Subtract the capacity of each bin from the weighted sum\\n scores = (weights - bins) + 10\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Score bins by subtracting the item size from half the bin capacity and dividing by the absolute difference between the half bin capacity and item size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / abs(bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the rest capacity and an increasing linear function of the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities + (np.arange(len(rest_capacities)) + 1) * item\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the item size by the percentage of the bin's capacity that is greater than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item / bins) - (bins ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by multiplying their index by a weight, subtracting their capacity from the result, and adding a constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weights for each bin based on its index\\n weights = np.arange(len(bins)) * 0.5\\n \\n # Subtract the capacity of each bin from the weighted sum\\n scores = (weights - bins) + 10\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Score bins by subtracting the item size from half the bin capacity and dividing by the absolute difference between the half bin capacity and item size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / abs(bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the rest capacity and an increasing linear function of the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities + (np.arange(len(rest_capacities)) + 1) * item\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the item size by the percentage of the bin's capacity that is greater than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item / bins) - (bins ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of half of the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins / 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Score bins by subtracting the item size from half the bin capacity and dividing by the absolute difference between the half bin capacity and item size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / abs(bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Score bins by multiplying their index by a weight and adding their capacity to the result. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and capacity\\n scores = (np.arange(len(bins)) * item) + bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the item size by the percentage of the bin's capacity that is greater than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item / bins) - (bins ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of half of the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins / 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by subtracting a penalty from the sum of power of rest capacity and power of half of the item value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the penalty for each bin based on its rest capacity\\n penalties = np.power(bins - item, 2)\\n \\n # Calculate the score for each bin by subtracting the penalty\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Score bins by subtracting the item size from half the bin capacity and dividing by the absolute difference between the half bin capacity and item size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / abs(bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Score bins by multiplying their index by a weight and adding their capacity to the result. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and capacity\\n scores = (np.arange(len(bins)) * item) + bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by dividing the item size by the product of the bin index and the square of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = (item / (bins * bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of half of the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins / 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by subtracting a penalty from the sum of power of rest capacity and power of half of the item value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the penalty for each bin based on its rest capacity\\n penalties = np.power(bins - item, 2)\\n \\n # Calculate the score for each bin by subtracting the penalty\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Score bins by subtracting the item size from half the bin capacity and dividing by the absolute difference between the half bin capacity and item size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / abs(bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Score bins by multiplying their index by a weight and adding their capacity to the result. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and capacity\\n scores = (np.arange(len(bins)) * item) + bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by taking the ratio of its rest capacity to item size, subtracting the square root of its index, and adding the square root of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size\\n ratios = bins / item\\n \\n # Subtract the square root of the index of each bin\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n scores = ratios - sqrt_indices\\n \\n # Add the square root of the number of used bins\\n num_used_bins = len(bins) - np.count_nonzero(bins > item)\\n scores += np.sqrt(num_used_bins)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by dividing the item size by the product of the bin index and the square of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = (item / (bins * bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their product, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (item * bins) - (np.square(np.arange(len(bins))) / len(bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of half of the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins / 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the product of the square root of the difference between the bin's capacity and the item's size, and the inverse of the bin's index multiplied by the sine of the difference between the bin's capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = np.sqrt((bins - item) / bins) * (1 / np.sin(bins - item))\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Score bins by subtracting the item size from half the bin capacity and dividing by the absolute difference between the half bin capacity and item size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / abs(bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by taking the sum of the inverse of the difference between the bin's capacity and the item's size multiplied by the sine of the rest capacity divided by the item's size, and the square root of the inverse of the square of the bin's index multiplied by the cosine of the rest capacity divided by the item's size.\\\\\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the sine of the rest capacity divided by the item's size\\n sin_rest = np.sin(inv_diff * item)\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_index = np.sqrt(inv_diff ** 2)\\n \\n # Compute the cosine of the rest capacity divided by the item's size\\n cos_rest = np.cos(sqrt_index * item)\\n \\n # Compute the final score for each bin\\n scores = inv_diff + sin_rest + cos_rest\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_inv_sq_idx = np.sqrt(inv_sq_diff)\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Compute the final score\\n scores = inv_sq_diff + sqrt_inv_sq_idx + sq_cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item) ** 2\\n # Calculate the final score\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (bins ** 2)\\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_sq_rest_capacity = np.sin(np.square(bins - item))\\n # Multiply the three terms together\\n scores = inv_diff * inv_sq_idx * sin_sq_rest_capacity\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by taking the ratio of its rest capacity to item size, subtracting the square root of its index, and adding the square root of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size\\n ratios = bins / item\\n \\n # Subtract the square root of the index of each bin\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n scores = ratios - sqrt_indices\\n \\n # Add the square root of the number of used bins\\n num_used_bins = len(bins) - np.count_nonzero(bins > item)\\n scores += np.sqrt(num_used_bins)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by dividing the item size by the product of the bin index and the square of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = (item / (bins * bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their product, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (item * bins) - (np.square(np.arange(len(bins))) / len(bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of half of the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins / 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score, calculated as the difference between the square root of the bin's index and the natural logarithm of the sum of the bin's rest capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the difference between the square root of the bin index and the natural logarithm of the sum of the bin rest capacity and the item size\\n scores = np.sqrt(np.arange(len(bins))) - np.log(bins + item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the product of the square root of the difference between the bin's capacity and the item's size, and the inverse of the bin's index multiplied by the sine of the difference between the bin's capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the scores for each bin\\n scores = np.sqrt((bins - item) / bins) * (1 / np.sin(bins - item))\\n \\n # Normalize the scores to ensure they sum to 1\\n scores = scores / np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm considers the rest capacity of each bin in relation to the item's size, calculates the ratio of the item's size to the bin's rest capacity, and normalizes the scores based on the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item's size to the bin's rest capacity\\n ratios = item / (bins - item)\\n \\n # Normalize the scores based on the item's size\\n scores = ratios / np.max(ratios)\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin based on the sum of the bin's rest capacity divided by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Calculate the sum of the bin's rest capacity divided by the power of 2\\n scores = (bins - item) / powers\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 4 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 4 for the indices of the bins\\n powers_of_4 = np.power(4, np.arange(len(bins)))\\n \\n # Multiply the square root rest capacities by the powers of 4\\n scores = sqrt_rest_capacities * powers_of_4\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate available capacity as the minimum of the remaining capacity or the item size, then score each bin as the available capacity times a penalty factor if the bin has less than 50% spare capacity, otherwise set the score to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate available capacity for each bin\\n available_capacity = np.minimum(bins, item)\\n \\n # Penalize bins with less than 50% spare capacity\\n penalties = np.where(available_capacity < 0.5 * bins, available_capacity, 0)\\n \\n # Score each bin based on available capacity and penalties\\n scores = available_capacity - penalties\\n \\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 2 raised to the indices of the bins\\n powers_of_two = 2 ** np.arange(len(bins))\\n \\n # Multiply the square root rest capacities by the powers of two\\n scores = sqrt_rest_capacities * powers_of_two\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Adjusted algorithm: Calculates bin scores as the weighted sum of the rest capacity to the power of 0.5, the proximity to the item size, and a penalty for exceeding the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity to the power of 0.5, the proximity to the item size, and a penalty for exceeding the maximum capacity\\n scores = (bins / np.sqrt(bins)) * (np.abs(item - bins) ** 0.5) + (bins > item) * (bins - item)\\n \\n # Penalize bins that exceed the maximum capacity\\n scores[bins > item] -= (bins[bins > item] - item) ** 2\\n \\n return scores\",\n \"objective\": 0.04568,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores bins as a product of their rest capacity and the inverse of the maximum score of all bins, with bins at maximum capacity receiving a score of zero and prioritizing larger rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum score for each bin\\n max_scores = np.maximum(0, bins - item)\\n \\n # Calculate the inverse of the maximum score for each bin\\n inv_max_scores = np.reciprocal(max_scores)\\n \\n # Calculate the product of the rest capacity and the inverse of the maximum score for each bin\\n scores = np.multiply(bins, inv_max_scores)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.0492,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Instead of dividing the capacities by the item size, the new algorithm takes the absolute difference between the capacities and the item size, then divides by the maximum of that difference or 1, and penalizes bins with maximum capacity with a score of 0\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the capacities and the item size\\n diff = np.abs(bins - item)\\n \\n # Divide the absolute difference by the maximum of that difference or 1\\n norm_diff = diff / np.maximum(diff, 1)\\n \\n # Penalize bins with maximum capacity with a score of 0\\n scores = norm_diff * (1 - (bins == bins.max()))\\n \\n return scores\",\n \"objective\": 0.05091,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the multiplication of the rest capacity, the inversly exponential decay of index and a power of the ratio of the item to the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the inverse exponential decay of the indices\\n indices = np.arange(len(rest_capacities))\\n decays = np.exp(-indices / len(rest_capacities))\\n \\n # Calculate the ratios of the item to the rest capacities\\n ratios = item / rest_capacities\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities * decays) ** ratios\\n \\n return scores\",\n \"objective\": 0.0655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin based on the sum of the bin's rest capacity multiplied by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Multiply the rest capacity of each bin by its corresponding power\\n scores = powers * (bins - item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.07959,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Assigning item to the bin with highest score which is sum of square of inverse of rest capacity, logarithm of rest capacity divided by item size, and cube root of bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the logarithm of the rest capacity for each bin\\n log_rest_capacity = np.log(inv_rest_capacity)\\n \\n # Calculate the cube root of the bin index for each bin\\n cube_root_bin_index = np.cbrt(np.arange(len(bins)))\\n \\n # Calculate the score for each bin using the formula you provided\\n scores = inv_rest_capacity * log_rest_capacity + cube_root_bin_index\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by taking the sum of the inverse of the difference between the bin's capacity and the item's size multiplied by the sine of the rest capacity divided by the item's size, and the square root of the inverse of the square of the bin's index multiplied by the cosine of the rest capacity divided by the item's size.\\\\\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the sine of the rest capacity divided by the item's size\\n sin_rest = np.sin(inv_diff * item)\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_index = np.sqrt(inv_diff ** 2)\\n \\n # Compute the cosine of the rest capacity divided by the item's size\\n cos_rest = np.cos(sqrt_index * item)\\n \\n # Compute the final score for each bin\\n scores = inv_diff + sin_rest + cos_rest\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_inv_sq_idx = np.sqrt(inv_sq_diff)\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Compute the final score\\n scores = inv_sq_diff + sqrt_inv_sq_idx + sq_cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item) ** 2\\n # Calculate the final score\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (bins ** 2)\\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_sq_rest_capacity = np.sin(np.square(bins - item))\\n # Multiply the three terms together\\n scores = inv_diff * inv_sq_idx * sin_sq_rest_capacity\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (bins - item) - (np.arange(len(bins)) ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by taking the ratio of its rest capacity to item size, subtracting the square root of its index, and adding the square root of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size\\n ratios = bins / item\\n \\n # Subtract the square root of the index of each bin\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n scores = ratios - sqrt_indices\\n \\n # Add the square root of the number of used bins\\n num_used_bins = len(bins) - np.count_nonzero(bins > item)\\n scores += np.sqrt(num_used_bins)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by dividing the item size by the product of the bin index and the square of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = (item / (bins * bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their product, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (item * bins) - (np.square(np.arange(len(bins))) / len(bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of half of the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins / 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of the rest capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Assigning item to the bin with highest score which is sum of square of inverse of rest capacity, logarithm of rest capacity divided by item size, and cube root of bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity for each bin\\n inv_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the logarithm of the rest capacity for each bin\\n log_rest_capacity = np.log(inv_rest_capacity)\\n \\n # Calculate the cube root of the bin index for each bin\\n cube_root_bin_index = np.cbrt(np.arange(len(bins)))\\n \\n # Calculate the score for each bin using the formula you provided\\n scores = inv_rest_capacity * log_rest_capacity + cube_root_bin_index\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by taking the sum of the inverse of the difference between the bin's capacity and the item's size multiplied by the sine of the rest capacity divided by the item's size, and the square root of the inverse of the square of the bin's index multiplied by the cosine of the rest capacity divided by the item's size.\\\\\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the sine of the rest capacity divided by the item's size\\n sin_rest = np.sin(inv_diff * item)\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_index = np.sqrt(inv_diff ** 2)\\n \\n # Compute the cosine of the rest capacity divided by the item's size\\n cos_rest = np.cos(sqrt_index * item)\\n \\n # Compute the final score for each bin\\n scores = inv_diff + sin_rest + cos_rest\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign item to the bin with the maximum score computed by finding the square of the sum of the square root of the bin's capacity divided by the item's size and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the square of the sum of the square root of the bin's capacity divided by the item's size\\n sqrt_capacity = np.sqrt(bins)\\n capacity_sum = np.sum(sqrt_capacity)\\n capacity_sqr = capacity_sum ** 2\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cosine = np.cos(np.pi * (bins - item) / item)\\n cosine_sqr = cosine ** 2\\n \\n # Compute the final score\\n scores = capacity_sqr + cosine_sqr\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the sine of the rest capacity divided by the item's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the sine of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(inv_rest_capacity * item) ** 2\\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + sin_rest_capacity\\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_inv_sq_idx = np.sqrt(inv_sq_diff)\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Compute the final score\\n scores = inv_sq_diff + sqrt_inv_sq_idx + sq_cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item) ** 2\\n # Calculate the final score\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (bins ** 2)\\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_sq_rest_capacity = np.sin(np.square(bins - item))\\n # Multiply the three terms together\\n scores = inv_diff * inv_sq_idx * sin_sq_rest_capacity\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (bins - item) - (np.arange(len(bins)) ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by taking the ratio of its rest capacity to item size, subtracting the square root of its index, and adding the square root of the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size\\n ratios = bins / item\\n \\n # Subtract the square root of the index of each bin\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n scores = ratios - sqrt_indices\\n \\n # Add the square root of the number of used bins\\n num_used_bins = len(bins) - np.count_nonzero(bins > item)\\n scores += np.sqrt(num_used_bins)\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by dividing the item size by the product of the bin index and the square of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = (item / (bins * bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their product, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (item * bins) - (np.square(np.arange(len(bins))) / len(bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score by subtracting the square root of the bin\\u2019s index multiplied by the item size and the square root of half of the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(np.arange(len(bins)) * item) - np.sqrt(bins / 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate bins scores by summing the hyperbolic tangent of the negative difference between the bin capacity and the item size, and the cube root of the positive difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the hyperbolic tangent of the negative difference between the bin capacity and the item size\\n t = np.tanh(-(bins - item))\\n \\n # Calculate the cube root of the positive difference between the bin's index and the number of bins\\n r = np.cbrt(bins - np.arange(len(bins)))\\n \\n # Sum the hyperbolic tangent and cube root\\n scores = t + r\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by taking the sum of the inverse of the difference between the bin's capacity and the item's size multiplied by the sine of the rest capacity divided by the item's size, and the square root of the inverse of the square of the bin's index multiplied by the cosine of the rest capacity divided by the item's size.\\\\\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the sine of the rest capacity divided by the item's size\\n sin_rest = np.sin(inv_diff * item)\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_index = np.sqrt(inv_diff ** 2)\\n \\n # Compute the cosine of the rest capacity divided by the item's size\\n cos_rest = np.cos(sqrt_index * item)\\n \\n # Compute the final score for each bin\\n scores = inv_diff + sin_rest + cos_rest\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign item to the bin with the maximum score computed by finding the square of the sum of the square root of the bin's capacity divided by the item's size and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the square of the sum of the square root of the bin's capacity divided by the item's size\\n sqrt_capacity = np.sqrt(bins)\\n capacity_sum = np.sum(sqrt_capacity)\\n capacity_sqr = capacity_sum ** 2\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cosine = np.cos(np.pi * (bins - item) / item)\\n cosine_sqr = cosine ** 2\\n \\n # Compute the final score\\n scores = capacity_sqr + cosine_sqr\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the sine of the rest capacity divided by the item's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the sine of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(inv_rest_capacity * item) ** 2\\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + sin_rest_capacity\\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_inv_sq_idx = np.sqrt(inv_sq_diff)\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Compute the final score\\n scores = inv_sq_diff + sqrt_inv_sq_idx + sq_cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item) ** 2\\n # Calculate the final score\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index multiplied by 0.5, and the square of the cosine of the rest capacity multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index multiplied by 0.5\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)) * 0.5)\\n # Calculate the square of the cosine of the rest capacity multiplied by item size\\n cos_rest_capacity = np.cos(np.deg2rad(bins) * item) ** 2\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (bins ** 2)\\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_sq_rest_capacity = np.sin(np.square(bins - item))\\n # Multiply the three terms together\\n scores = inv_diff * inv_sq_idx * sin_sq_rest_capacity\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by dividing the sum of item size and half of rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins / 2) / (bins - item)\\n \\n # Subtract the square of the bin index from the scores\\n scores -= np.square(np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (bins - item) - (np.arange(len(bins)) ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = np.divide(np.ones(len(bins)), np.subtract(bins, item))\\n # Add a random number between 0 and 1 to the inverse of the difference\\n rand = np.random.uniform(size=inv_diff.shape)\\n scores = np.multiply(inv_diff, rand)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by dividing the item size by the product of the bin index and the square of its rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin\\n scores = (item / (bins * bins))\\n \\n # Return the scores in descending order\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function for bins is calculated as the exponential decay of the difference between item size and rest capacity, multiplied with the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential decay of the difference between item size and rest capacity\\n decay = np.exp(-(bins - item) / (bins * item))\\n \\n # Multiply the decay by the bin index\\n scores = decay * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate bins scores by summing the hyperbolic tangent of the negative difference between the bin capacity and the item size, and the cube root of the positive difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the hyperbolic tangent of the negative difference between the bin capacity and the item size\\n t = np.tanh(-(bins - item))\\n \\n # Calculate the cube root of the positive difference between the bin's index and the number of bins\\n r = np.cbrt(bins - np.arange(len(bins)))\\n \\n # Sum the hyperbolic tangent and cube root\\n scores = t + r\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by taking the sum of the inverse of the difference between the bin's capacity and the item's size multiplied by the sine of the rest capacity divided by the item's size, and the square root of the inverse of the square of the bin's index multiplied by the cosine of the rest capacity divided by the item's size.\\\\\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the sine of the rest capacity divided by the item's size\\n sin_rest = np.sin(inv_diff * item)\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_index = np.sqrt(inv_diff ** 2)\\n \\n # Compute the cosine of the rest capacity divided by the item's size\\n cos_rest = np.cos(sqrt_index * item)\\n \\n # Compute the final score for each bin\\n scores = inv_diff + sin_rest + cos_rest\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign item to the bin with the maximum score computed by finding the square of the sum of the square root of the bin's capacity divided by the item's size and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the square of the sum of the square root of the bin's capacity divided by the item's size\\n sqrt_capacity = np.sqrt(bins)\\n capacity_sum = np.sum(sqrt_capacity)\\n capacity_sqr = capacity_sum ** 2\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cosine = np.cos(np.pi * (bins - item) / item)\\n cosine_sqr = cosine ** 2\\n \\n # Compute the final score\\n scores = capacity_sqr + cosine_sqr\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the sine of the rest capacity divided by the item's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the sine of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(inv_rest_capacity * item) ** 2\\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + sin_rest_capacity\\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_inv_sq_idx = np.sqrt(inv_sq_diff)\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Compute the final score\\n scores = inv_sq_diff + sqrt_inv_sq_idx + sq_cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item) ** 2\\n # Calculate the final score\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n sq_cos_rest = np.square(np.cos(bins * item))\\n \\n # Compute the total score for each bin\\n scores = inv_sq_diff + sq_cos_rest\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index multiplied by 0.5, and the square of the cosine of the rest capacity multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index multiplied by 0.5\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)) * 0.5)\\n # Calculate the square of the cosine of the rest capacity multiplied by item size\\n cos_rest_capacity = np.cos(np.deg2rad(bins) * item) ** 2\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the cube of the difference between the bin's capacity and the item's size, the cube root of the sum of the inverse of the square of the bin's index, and the square of the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the cube of the difference between the bin's capacity and the item's size\\n inv_sq_cube_diff = 1 / (np.square(bins - item) ** 3)\\n \\n # Compute the cube root of the sum of the inverse of the square of the bin's index\\n cube_root_sum = np.sqrt(np.sum(inv_sq_cube_diff))\\n \\n # Compute the square of the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item) ** 2\\n \\n # Compute the final score\\n scores = inv_sq_cube_diff + cube_root_sum + cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (bins ** 2)\\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_sq_rest_capacity = np.sin(np.square(bins - item))\\n # Multiply the three terms together\\n scores = inv_diff * inv_sq_idx * sin_sq_rest_capacity\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by multiplying the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size, and the cosine of the square of the rest capacity divided by the item's size, by the square root of the sum of the inverse of the square of the bin's index, and the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size\\n inv_sum_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.square(bins - item))\\n \\n # Compute the square root of the sum of the inverse of the square of the bin's index\\n sqrt_inv_bin_index = np.sqrt(np.square(np.arange(len(bins))))\\n \\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(np.square(bins - item))\\n \\n # Multiply the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size, and the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sum_sq_diff * cos_rest_capacity\\n \\n # Add the square root of the sum of the inverse of the square of the bin's index\\n scores += sqrt_inv_bin_index\\n \\n # Add the sine of the square of the rest capacity divided by the item's size\\n scores += sin_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by dividing the sum of item size and half of rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins / 2) / (bins - item)\\n \\n # Subtract the square of the bin index from the scores\\n scores -= np.square(np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (bins - item) - (np.arange(len(bins)) ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and a random number between 0 and 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = np.divide(np.ones(len(bins)), np.subtract(bins, item))\\n # Add a random number between 0 and 1 to the inverse of the difference\\n rand = np.random.uniform(size=inv_diff.shape)\\n scores = np.multiply(inv_diff, rand)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"Compute the bin scores by multiplying the tanh of the negative difference between the bin capacity and the item size with the square root of the positive difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the tanh of the negative difference between the bin capacity and the item size\\n diff = np.tanh(-(bins - item))\\n \\n # Compute the square root of the positive difference between the bin's index and the number of bins\\n sqrt_diff = np.sqrt(np.abs(bins - np.arange(len(bins))))\\n \\n # Multiply the tanh and square root differences to get the final scores\\n scores = diff * sqrt_diff\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bins scores by summing the hyperbolic tangent of the negative difference between the bin capacity and the item size, and the cube root of the positive difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the hyperbolic tangent of the negative difference between the bin capacity and the item size\\n t = np.tanh(-(bins - item))\\n \\n # Calculate the cube root of the positive difference between the bin's index and the number of bins\\n r = np.cbrt(bins - np.arange(len(bins)))\\n \\n # Sum the hyperbolic tangent and cube root\\n scores = t + r\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by taking the sum of the inverse of the difference between the bin's capacity and the item's size multiplied by the sine of the rest capacity divided by the item's size, and the square root of the inverse of the square of the bin's index multiplied by the cosine of the rest capacity divided by the item's size.\\\\\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the sine of the rest capacity divided by the item's size\\n sin_rest = np.sin(inv_diff * item)\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_index = np.sqrt(inv_diff ** 2)\\n \\n # Compute the cosine of the rest capacity divided by the item's size\\n cos_rest = np.cos(sqrt_index * item)\\n \\n # Compute the final score for each bin\\n scores = inv_diff + sin_rest + cos_rest\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign item to the bin with the maximum score computed by finding the square of the sum of the square root of the bin's capacity divided by the item's size and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the square of the sum of the square root of the bin's capacity divided by the item's size\\n sqrt_capacity = np.sqrt(bins)\\n capacity_sum = np.sum(sqrt_capacity)\\n capacity_sqr = capacity_sum ** 2\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cosine = np.cos(np.pi * (bins - item) / item)\\n cosine_sqr = cosine ** 2\\n \\n # Compute the final score\\n scores = capacity_sqr + cosine_sqr\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the sine of the rest capacity divided by the item's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the sine of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(inv_rest_capacity * item) ** 2\\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + sin_rest_capacity\\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the natural logarithm of the bin index, and the sine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the natural logarithm of the bin index\\n log_bin_index = np.log(np.arange(len(bins)))\\n # Calculate the sine of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(inv_rest_capacity * item)\\n \\n # Combine the three components into a single score\\n scores = inv_rest_capacity + log_bin_index + sin_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_inv_sq_idx = np.sqrt(inv_sq_diff)\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Compute the final score\\n scores = inv_sq_diff + sqrt_inv_sq_idx + sq_cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item) ** 2\\n # Calculate the final score\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n sq_cos_rest = np.square(np.cos(bins * item))\\n \\n # Compute the total score for each bin\\n scores = inv_sq_diff + sq_cos_rest\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index multiplied by 0.5, and the square of the cosine of the rest capacity multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index multiplied by 0.5\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)) * 0.5)\\n # Calculate the square of the cosine of the rest capacity multiplied by item size\\n cos_rest_capacity = np.cos(np.deg2rad(bins) * item) ** 2\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the cube of the difference between the bin's capacity and the item's size, the cube root of the sum of the inverse of the square of the bin's index, and the square of the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the cube of the difference between the bin's capacity and the item's size\\n inv_sq_cube_diff = 1 / (np.square(bins - item) ** 3)\\n \\n # Compute the cube root of the sum of the inverse of the square of the bin's index\\n cube_root_sum = np.sqrt(np.sum(inv_sq_cube_diff))\\n \\n # Compute the square of the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item) ** 2\\n \\n # Compute the final score\\n scores = inv_sq_cube_diff + cube_root_sum + cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (bins ** 2)\\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_sq_rest_capacity = np.sin(np.square(bins - item))\\n # Multiply the three terms together\\n scores = inv_diff * inv_sq_idx * sin_sq_rest_capacity\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score by multiplying the inverse square of the sum of the difference between the bin's capacity and the item's size, and the square of the cosine of the rest capacity divided by the item's size, by the square root of the sum of the inverse of the square of the bin's index and the sine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse square of the sum of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(bins * item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Calculate the square root of the sum of the inverse of the square of the bin's index and the sine of the rest capacity divided by the item's size\\n sqrt_inv_sq_bin_index = np.sqrt(np.square(np.arange(len(bins))) + 1e-8)\\n sin_rest_capacity = np.sin(bins * item)\\n sq_sin_rest_capacity = np.square(sin_rest_capacity)\\n \\n # Multiply the inverse square of the sum of the difference between the bin's capacity and the item's size, and the square of the cosine of the rest capacity divided by the item's size\\n scores = inv_sq_diff * sq_cos_rest_capacity\\n \\n # Add the square root of the sum of the inverse of the square of the bin's index and the sine of the rest capacity divided by the item's size\\n scores += sqrt_inv_sq_bin_index * sq_sin_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by multiplying the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size, and the cosine of the square of the rest capacity divided by the item's size, by the square root of the sum of the inverse of the square of the bin's index, and the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size\\n inv_sum_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.square(bins - item))\\n \\n # Compute the square root of the sum of the inverse of the square of the bin's index\\n sqrt_inv_bin_index = np.sqrt(np.square(np.arange(len(bins))))\\n \\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(np.square(bins - item))\\n \\n # Multiply the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size, and the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sum_sq_diff * cos_rest_capacity\\n \\n # Add the square root of the sum of the inverse of the square of the bin's index\\n scores += sqrt_inv_bin_index\\n \\n # Add the sine of the square of the rest capacity divided by the item's size\\n scores += sin_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the cube of the bin's index, multiplied by the sine of the cube of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the inverse of the cube of the bin's index\\n inv_cube_idx = 1 / (np.power(np.arange(len(bins)), 3))\\n \\n # Compute the sine of the cube of the rest capacity divided by the item's size\\n sin_cube_rest = np.sin(np.power(bins - item, 3) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the cube of the bin's index, by the sine of the cube of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_cube_idx * sin_cube_rest\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by dividing the sum of item size and half of rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins / 2) / (bins - item)\\n \\n # Subtract the square of the bin index from the scores\\n scores -= np.square(np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by dividing the sum of item size and rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins) / (bins - item) - (np.arange(len(bins)) ** 2)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the bin index, and the tangent of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the bin index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the tangent of the rest capacity divided by the item size\\n tan_rest_capacity = np.tan((bins - item) / item)\\n \\n # Calculate the final scores\\n scores = inv_rest_capacity + sqrt_bin_index + tan_rest_capacity\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the bin scores by multiplying the tanh of the negative difference between the bin capacity and the item size with the square root of the positive difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the tanh of the negative difference between the bin capacity and the item size\\n diff = np.tanh(-(bins - item))\\n \\n # Compute the square root of the positive difference between the bin's index and the number of bins\\n sqrt_diff = np.sqrt(np.abs(bins - np.arange(len(bins))))\\n \\n # Multiply the tanh and square root differences to get the final scores\\n scores = diff * sqrt_diff\\n \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bins scores by summing the hyperbolic tangent of the negative difference between the bin capacity and the item size, and the cube root of the positive difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the hyperbolic tangent of the negative difference between the bin capacity and the item size\\n t = np.tanh(-(bins - item))\\n \\n # Calculate the cube root of the positive difference between the bin's index and the number of bins\\n r = np.cbrt(bins - np.arange(len(bins)))\\n \\n # Sum the hyperbolic tangent and cube root\\n scores = t + r\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by taking the sum of the inverse of the difference between the bin's capacity and the item's size multiplied by the sine of the rest capacity divided by the item's size, and the square root of the inverse of the square of the bin's index multiplied by the cosine of the rest capacity divided by the item's size.\\\\\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the sine of the rest capacity divided by the item's size\\n sin_rest = np.sin(inv_diff * item)\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_index = np.sqrt(inv_diff ** 2)\\n \\n # Compute the cosine of the rest capacity divided by the item's size\\n cos_rest = np.cos(sqrt_index * item)\\n \\n # Compute the final score for each bin\\n scores = inv_diff + sin_rest + cos_rest\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign item to the bin with the maximum score computed by finding the square of the sum of the square root of the bin's capacity divided by the item's size and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the square of the sum of the square root of the bin's capacity divided by the item's size\\n sqrt_capacity = np.sqrt(bins)\\n capacity_sum = np.sum(sqrt_capacity)\\n capacity_sqr = capacity_sum ** 2\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cosine = np.cos(np.pi * (bins - item) / item)\\n cosine_sqr = cosine ** 2\\n \\n # Compute the final score\\n scores = capacity_sqr + cosine_sqr\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the sine of the rest capacity divided by the item's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the sine of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(inv_rest_capacity * item) ** 2\\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + sin_rest_capacity\\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the natural logarithm of the bin index, and the sine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the natural logarithm of the bin index\\n log_bin_index = np.log(np.arange(len(bins)))\\n # Calculate the sine of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(inv_rest_capacity * item)\\n \\n # Combine the three components into a single score\\n scores = inv_rest_capacity + log_bin_index + sin_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02908,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square root of the inverse of the square of the bin's index\\n sqrt_inv_sq_idx = np.sqrt(inv_sq_diff)\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Compute the final score\\n scores = inv_sq_diff + sqrt_inv_sq_idx + sq_cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)))\\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.pi * (bins - item) / item) ** 2\\n # Calculate the final score\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the square of the cosine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the square of the cosine of the rest capacity divided by the item's size\\n sq_cos_rest = np.square(np.cos(bins * item))\\n \\n # Compute the total score for each bin\\n scores = inv_sq_diff + sq_cos_rest\\n \\n return scores\",\n \"objective\": 0.03039,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by summing the inverse of the rest capacity divided by the item size, the square root of the inverse of the square of the bin's index multiplied by 0.5, and the square of the cosine of the rest capacity multiplied by item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity divided by the item size\\n inv_rest_capacity = 1 / (bins - item)\\n # Calculate the square root of the inverse of the square of the bin's index multiplied by 0.5\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)) * 0.5)\\n # Calculate the square of the cosine of the rest capacity multiplied by item size\\n cos_rest_capacity = np.cos(np.deg2rad(bins) * item) ** 2\\n \\n # Calculate the total score for each bin\\n scores = inv_rest_capacity + sqrt_bin_index + cos_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the difference between the bin's capacity and the item's size, and the bin's index multiplied by the cosine of the square of the rest capacity divided by the item's size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sqr = np.cos(np.square(bins * inv_diff))\\n \\n # Compute the sum of the inverse of the difference and the cosine\\n scores = inv_diff + cos_sqr\\n \\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the cube of the difference between the bin's capacity and the item's size, the cube root of the sum of the inverse of the square of the bin's index, and the square of the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the cube of the difference between the bin's capacity and the item's size\\n inv_sq_cube_diff = 1 / (np.square(bins - item) ** 3)\\n \\n # Compute the cube root of the sum of the inverse of the square of the bin's index\\n cube_root_sum = np.sqrt(np.sum(inv_sq_cube_diff))\\n \\n # Compute the square of the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item) ** 2\\n \\n # Compute the final score\\n scores = inv_sq_cube_diff + cube_root_sum + cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by finding the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (np.square(np.arange(len(bins))) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_sq_rest_capacity = np.cos(np.square(bins - item) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, by the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_sq_idx * cos_sq_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the difference between the bin's capacity and the item's size, and the inverse of the square of the bin's index, multiplied by the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the difference between the bin's capacity and the item's size\\n inv_diff = 1 / (bins - item)\\n # Compute the inverse of the square of the bin's index\\n inv_sq_idx = 1 / (bins ** 2)\\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_sq_rest_capacity = np.sin(np.square(bins - item))\\n # Multiply the three terms together\\n scores = inv_diff * inv_sq_idx * sin_sq_rest_capacity\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score by multiplying the inverse square of the sum of the difference between the bin's capacity and the item's size, and the square of the cosine of the rest capacity divided by the item's size, by the square root of the sum of the inverse of the square of the bin's index and the sine of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse square of the sum of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Calculate the square of the cosine of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(bins * item)\\n sq_cos_rest_capacity = np.square(cos_rest_capacity)\\n \\n # Calculate the square root of the sum of the inverse of the square of the bin's index and the sine of the rest capacity divided by the item's size\\n sqrt_inv_sq_bin_index = np.sqrt(np.square(np.arange(len(bins))) + 1e-8)\\n sin_rest_capacity = np.sin(bins * item)\\n sq_sin_rest_capacity = np.square(sin_rest_capacity)\\n \\n # Multiply the inverse square of the sum of the difference between the bin's capacity and the item's size, and the square of the cosine of the rest capacity divided by the item's size\\n scores = inv_sq_diff * sq_cos_rest_capacity\\n \\n # Add the square root of the sum of the inverse of the square of the bin's index and the sine of the rest capacity divided by the item's size\\n scores += sqrt_inv_sq_bin_index * sq_sin_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score computed by multiplying the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size, and the cosine of the square of the rest capacity divided by the item's size, by the square root of the sum of the inverse of the square of the bin's index, and the sine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size\\n inv_sum_sq_diff = 1 / (np.square(bins - item) + 1e-8)\\n \\n # Compute the cosine of the square of the rest capacity divided by the item's size\\n cos_rest_capacity = np.cos(np.square(bins - item))\\n \\n # Compute the square root of the sum of the inverse of the square of the bin's index\\n sqrt_inv_bin_index = np.sqrt(np.square(np.arange(len(bins))))\\n \\n # Compute the sine of the square of the rest capacity divided by the item's size\\n sin_rest_capacity = np.sin(np.square(bins - item))\\n \\n # Multiply the inverse of the sum of the square of the inverse of the difference between the bin's capacity and the item's size, and the cosine of the square of the rest capacity divided by the item's size\\n scores = inv_sum_sq_diff * cos_rest_capacity\\n \\n # Add the square root of the sum of the inverse of the square of the bin's index\\n scores += sqrt_inv_bin_index\\n \\n # Add the sine of the square of the rest capacity divided by the item's size\\n scores += sin_rest_capacity\\n \\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the maximum score computed as the sum of the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the cube of the bin's index, multiplied by the sine of the cube of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the inverse of the square of the difference between the bin's capacity and the item's size\\n inv_sq_diff = 1 / (np.square(bins - item))\\n \\n # Compute the inverse of the cube of the bin's index\\n inv_cube_idx = 1 / (np.power(np.arange(len(bins)), 3))\\n \\n # Compute the sine of the cube of the rest capacity divided by the item's size\\n sin_cube_rest = np.sin(np.power(bins - item, 3) / item)\\n \\n # Multiply the inverse of the square of the difference between the bin's capacity and the item's size, and the inverse of the cube of the bin's index, by the sine of the cube of the rest capacity divided by the item's size\\n scores = inv_sq_diff * inv_cube_idx * sin_cube_rest\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bins scores by summing the exponential of the negative difference between bin capacity and item size, and the logarithm of the negative difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the exponential of the negative difference between bin capacity and item size\\n exp_diff = np.exp(-(bins - item))\\n \\n # Calculate the logarithm of the negative difference between the bin's index and the number of bins\\n log_diff = np.log(-(np.arange(len(bins)) - len(bins)))\\n \\n # Sum the two terms to get the total score for each bin\\n scores = exp_diff + log_diff\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by dividing the sum of item size and half of rest capacity by their difference, then subtracting the square of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (item + bins / 2) / (bins - item)\\n \\n # Subtract the square of the bin index from the scores\\n scores -= np.square(np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its reciprocal multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the reciprocal of each bin's rest capacity\\n reciprocal_rest_capacity = 1 / (bins - item)\\n \\n # Calculate the score for each bin\\n scores = reciprocal_rest_capacity * item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is calculated as the multiplication of the ratio of the item to the rest capacity, the rest capacity and the exponential decay of the index. Score(bin) = (item / rest capacity) * rest capacity * exp(-index / number of bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item to the rest capacity\\n ratio = item / (bins - 1)\\n \\n # Calculate the exponential decay of the index\\n decay = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Multiply the ratio and the exponential decay to get the scores\\n scores = ratio * decay * bins\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin based on the sum of the bin's rest capacity divided by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Calculate the sum of the bin's rest capacity divided by the power of 2\\n scores = (bins - item) / powers\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will score the bins based on a combination of their rest capacities and the entropy of the distribution of rest capacities among the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the entropy of the distribution of rest capacities\\n entropy = np.sum(-rest_capacities * np.log(rest_capacities))\\n \\n # Calculate the scores for each bin based on its rest capacity and entropy\\n scores = rest_capacities / (entropy + 1e-6)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 4 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 4 for the indices of the bins\\n powers_of_4 = np.power(4, np.arange(len(bins)))\\n \\n # Multiply the square root rest capacities by the powers of 4\\n scores = sqrt_rest_capacities * powers_of_4\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate available capacity as the minimum of the remaining capacity or the item size, then score each bin as the available capacity times a penalty factor if the bin has less than 50% spare capacity, otherwise set the score to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate available capacity for each bin\\n available_capacity = np.minimum(bins, item)\\n \\n # Penalize bins with less than 50% spare capacity\\n penalties = np.where(available_capacity < 0.5 * bins, available_capacity, 0)\\n \\n # Score each bin based on available capacity and penalties\\n scores = available_capacity - penalties\\n \\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the ratio of the item size to the rest capacity, multiplied by the exponential of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity\\n ratios = item / (bins - item)\\n \\n # Calculate the exponential of the bin indices\\n exponents = np.exp(np.arange(len(bins)))\\n \\n # Multiply the ratios and exponents element-wise\\n scores = ratios * exponents\\n \\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 2 raised to the indices of the bins\\n powers_of_two = 2 ** np.arange(len(bins))\\n \\n # Multiply the square root rest capacities by the powers of two\\n scores = sqrt_rest_capacities * powers_of_two\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin as the natural logarithm of its rest capacity divided by the natural logarithm of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin\\n scores = np.log(bins) - np.log(np.arange(len(bins)) + 1)\\n \\n # Normalize the scores to ensure consistency\\n scores /= np.max(scores)\\n \\n # Return the normalized scores\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the square root of the rest capacity divided by the sum of its index and number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacity divided by the sum of its index and number of used bins\\n scores = np.sqrt(bins / (np.arange(len(bins)) + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin as the difference between the square root of its rest capacity and the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square roots of the rest capacities and indices\\n sqrt_rest_capacities = np.sqrt(bins)\\n sqrt_indices = np.arange(len(bins)) + 1\\n \\n # Calculate the scores for each bin\\n scores = sqrt_rest_capacities - sqrt_indices\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm scores each bin based on the product of the square root of the bin's rest capacity multiplied by the exponential of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = np.sqrt(bins) * np.exp(np.arange(len(bins)))\\n \\n # Normalize the scores to ensure they sum to 1\\n scores /= np.sum(scores)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Adjusted algorithm: Calculates bin scores as the weighted sum of the rest capacity to the power of 0.5, the proximity to the item size, and a penalty for exceeding the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted sum of the rest capacity to the power of 0.5, the proximity to the item size, and a penalty for exceeding the maximum capacity\\n scores = (bins / np.sqrt(bins)) * (np.abs(item - bins) ** 0.5) + (bins > item) * (bins - item)\\n \\n # Penalize bins that exceed the maximum capacity\\n scores[bins > item] -= (bins[bins > item] - item) ** 2\\n \\n return scores\",\n \"objective\": 0.04568,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"`New algorithm: Calculate scores based on a ratio between item size and rest capacity, penalized by the index of the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item size to rest capacity\\n ratios = item / (bins - item)\\n \\n # Penalize the index of the bin\\n penalties = np.arange(len(bins)) * 0.5\\n \\n # Combine the ratios and penalties into a single score vector\\n scores = ratios + penalties\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin by multiplying the ratio of the item size to the rest capacity with a function of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin by multiplying the ratio of the item size to the rest capacity with a function of the bin's index\\n scores = (item / (bins - item)) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is calculated as the multiplication of the ratio of the item to the rest capacity, the rest capacity and the exponential decay of the index. Score(bin) = (item / rest capacity) * rest capacity * exp(-index / number of bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item to the rest capacity\\n ratio = item / (bins - 1)\\n \\n # Calculate the exponential decay of the index\\n decay = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Multiply the ratio and the exponential decay to get the scores\\n scores = ratio * decay * bins\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin based on the sum of the bin's rest capacity divided by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Calculate the sum of the bin's rest capacity divided by the power of 2\\n scores = (bins - item) / powers\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: penalty formula, capacity ratio calculation. New algorithm: Calculate scores by adding the item's size to the rest capacity and dividing by the maximum capacity, multiplied by the penalty of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the penalty for each bin based on its index\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the capacity ratio for each bin\\n capacities = bins / (penalties * item)\\n \\n # Calculate the scores for each bin\\n scores = capacities - penalties\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 4 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 4 for the indices of the bins\\n powers_of_4 = np.power(4, np.arange(len(bins)))\\n \\n # Multiply the square root rest capacities by the powers of 4\\n scores = sqrt_rest_capacities * powers_of_4\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate available capacity as the minimum of the remaining capacity or the item size, then score each bin as the available capacity times a penalty factor if the bin has less than 50% spare capacity, otherwise set the score to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate available capacity for each bin\\n available_capacity = np.minimum(bins, item)\\n \\n # Penalize bins with less than 50% spare capacity\\n penalties = np.where(available_capacity < 0.5 * bins, available_capacity, 0)\\n \\n # Score each bin based on available capacity and penalties\\n scores = available_capacity - penalties\\n \\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the ratio of the item size to the rest capacity, multiplied by the exponential of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity\\n ratios = item / (bins - item)\\n \\n # Calculate the exponential of the bin indices\\n exponents = np.exp(np.arange(len(bins)))\\n \\n # Multiply the ratios and exponents element-wise\\n scores = ratios * exponents\\n \\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 2 raised to the indices of the bins\\n powers_of_two = 2 ** np.arange(len(bins))\\n \\n # Multiply the square root rest capacities by the powers of two\\n scores = sqrt_rest_capacities * powers_of_two\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin as the natural logarithm of its rest capacity divided by the natural logarithm of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic scores for each bin\\n scores = np.log(bins) - np.log(np.arange(len(bins)) + 1)\\n \\n # Normalize the scores to ensure consistency\\n scores /= np.max(scores)\\n \\n # Return the normalized scores\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the square root of the rest capacity divided by the sum of its index and number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacity divided by the sum of its index and number of used bins\\n scores = np.sqrt(bins / (np.arange(len(bins)) + 1))\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"`New algorithm: Calculate scores based on a ratio between item size and rest capacity, penalized by the index of the bin.`\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item size to rest capacity\\n ratios = item / (bins - item)\\n \\n # Penalize the index of the bin\\n penalties = np.arange(len(bins)) * 0.5\\n \\n # Combine the ratios and penalties into a single score vector\\n scores = ratios + penalties\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Alternative Algorithm: Calculate scores for each bin by subtracting the bin's capacity from the item's value and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from the item's value\\n scores = np.subtract(item, bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is calculated as the multiplication of the ratio of the item to the rest capacity, the rest capacity and the exponential decay of the index. Score(bin) = (item / rest capacity) * rest capacity * exp(-index / number of bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item to the rest capacity\\n ratio = item / (bins - 1)\\n \\n # Calculate the exponential decay of the index\\n decay = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Multiply the ratio and the exponential decay to get the scores\\n scores = ratio * decay * bins\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin based on the sum of the bin's rest capacity divided by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Calculate the sum of the bin's rest capacity divided by the power of 2\\n scores = (bins - item) / powers\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by calculating the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity\\n scores = (bins / (np.arange(len(bins)) + 1) ** 2) * item\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: penalty formula, capacity ratio calculation. New algorithm: Calculate scores by adding the item's size to the rest capacity and dividing by the maximum capacity, multiplied by the penalty of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the penalty for each bin based on its index\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the capacity ratio for each bin\\n capacities = bins / (penalties * item)\\n \\n # Calculate the scores for each bin\\n scores = capacities - penalties\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 4 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 4 for the indices of the bins\\n powers_of_4 = np.power(4, np.arange(len(bins)))\\n \\n # Multiply the square root rest capacities by the powers of 4\\n scores = sqrt_rest_capacities * powers_of_4\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate available capacity as the minimum of the remaining capacity or the item size, then score each bin as the available capacity times a penalty factor if the bin has less than 50% spare capacity, otherwise set the score to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate available capacity for each bin\\n available_capacity = np.minimum(bins, item)\\n \\n # Penalize bins with less than 50% spare capacity\\n penalties = np.where(available_capacity < 0.5 * bins, available_capacity, 0)\\n \\n # Score each bin based on available capacity and penalties\\n scores = available_capacity - penalties\\n \\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the ratio of the item size to the rest capacity, multiplied by the exponential of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item size to the rest capacity\\n ratios = item / (bins - item)\\n \\n # Calculate the exponential of the bin indices\\n exponents = np.exp(np.arange(len(bins)))\\n \\n # Multiply the ratios and exponents element-wise\\n scores = ratios * exponents\\n \\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 2 raised to the indices of the bins\\n powers_of_two = 2 ** np.arange(len(bins))\\n \\n # Multiply the square root rest capacities by the powers of two\\n scores = sqrt_rest_capacities * powers_of_two\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Alternative Algorithm: Calculate scores for each bin by subtracting the bin's capacity from the item's value and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from the item's value\\n scores = np.subtract(item, bins)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is calculated as the multiplication of the ratio of the item to the rest capacity, the rest capacity and the exponential decay of the index. Score(bin) = (item / rest capacity) * rest capacity * exp(-index / number of bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item to the rest capacity\\n ratio = item / (bins - 1)\\n \\n # Calculate the exponential decay of the index\\n decay = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Multiply the ratio and the exponential decay to get the scores\\n scores = ratio * decay * bins\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin based on the sum of the bin's rest capacity divided by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Calculate the sum of the bin's rest capacity divided by the power of 2\\n scores = (bins - item) / powers\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by dividing their capacity by a weight and adding their index to the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted capacity of each bin\\n weights = np.array([bin_capacity / item for bin_capacity in bins])\\n \\n # Add the index of each bin to the weighted capacity\\n scores = np.array([weight + i for i, weight in enumerate(weights)])\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by calculating the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity\\n scores = (bins / (np.arange(len(bins)) + 1) ** 2) * item\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: penalty formula, capacity ratio calculation. New algorithm: Calculate scores by adding the item's size to the rest capacity and dividing by the maximum capacity, multiplied by the penalty of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the penalty for each bin based on its index\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the capacity ratio for each bin\\n capacities = bins / (penalties * item)\\n \\n # Calculate the scores for each bin\\n scores = capacities - penalties\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 4 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 4 for the indices of the bins\\n powers_of_4 = np.power(4, np.arange(len(bins)))\\n \\n # Multiply the square root rest capacities by the powers of 4\\n scores = sqrt_rest_capacities * powers_of_4\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate available capacity as the minimum of the remaining capacity or the item size, then score each bin as the available capacity times a penalty factor if the bin has less than 50% spare capacity, otherwise set the score to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate available capacity for each bin\\n available_capacity = np.minimum(bins, item)\\n \\n # Penalize bins with less than 50% spare capacity\\n penalties = np.where(available_capacity < 0.5 * bins, available_capacity, 0)\\n \\n # Score each bin based on available capacity and penalties\\n scores = available_capacity - penalties\\n \\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Score bins as the inverse of the sum of rest capacity and the maximum capacity increment. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the sum of rest capacity and maximum capacity increment\\n scores = 1 / (bins + item)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is calculated as the multiplication of the ratio of the item to the rest capacity, the rest capacity and the exponential decay of the index. Score(bin) = (item / rest capacity) * rest capacity * exp(-index / number of bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item to the rest capacity\\n ratio = item / (bins - 1)\\n \\n # Calculate the exponential decay of the index\\n decay = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Multiply the ratio and the exponential decay to get the scores\\n scores = ratio * decay * bins\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin based on the sum of the bin's rest capacity divided by the power of 2 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the power of 2 raised to the index of each bin\\n powers = np.power(2, np.arange(len(bins)))\\n \\n # Calculate the sum of the bin's rest capacity divided by the power of 2\\n scores = (bins - item) / powers\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by dividing their capacity by a weight and adding their index to the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted capacity of each bin\\n weights = np.array([bin_capacity / item for bin_capacity in bins])\\n \\n # Add the index of each bin to the weighted capacity\\n scores = np.array([weight + i for i, weight in enumerate(weights)])\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by calculating the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity\\n scores = (bins / (np.arange(len(bins)) + 1) ** 2) * item\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: penalty formula, capacity ratio calculation. New algorithm: Calculate scores by adding the item's size to the rest capacity and dividing by the maximum capacity, multiplied by the penalty of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the penalty for each bin based on its index\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the capacity ratio for each bin\\n capacities = bins / (penalties * item)\\n \\n # Calculate the scores for each bin\\n scores = capacities - penalties\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 4 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 4 for the indices of the bins\\n powers_of_4 = np.power(4, np.arange(len(bins)))\\n \\n # Multiply the square root rest capacities by the powers of 4\\n scores = sqrt_rest_capacities * powers_of_4\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / (bins * (1 - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is calculated as the multiplication of the ratio of the item to the rest capacity, the rest capacity and the exponential decay of the index. Score(bin) = (item / rest capacity) * rest capacity * exp(-index / number of bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item to the rest capacity\\n ratio = item / (bins - 1)\\n \\n # Calculate the exponential decay of the index\\n decay = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Multiply the ratio and the exponential decay to get the scores\\n scores = ratio * decay * bins\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the rest capacity and the product of the item and the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities * (1 / np.exp(-np.arange(len(rest_capacities)) ** 2))\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by dividing their capacity by a weight and adding their index to the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the weighted capacity of each bin\\n weights = np.array([bin_capacity / item for bin_capacity in bins])\\n \\n # Add the index of each bin to the weighted capacity\\n scores = np.array([weight + i for i, weight in enumerate(weights)])\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by calculating the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity\\n scores = (bins / (np.arange(len(bins)) + 1) ** 2) * item\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main algorithm parameters: penalty formula, capacity ratio calculation. New algorithm: Calculate scores by adding the item's size to the rest capacity and dividing by the maximum capacity, multiplied by the penalty of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the penalty for each bin based on its index\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the capacity ratio for each bin\\n capacities = bins / (penalties * item)\\n \\n # Calculate the scores for each bin\\n scores = capacities - penalties\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm scores each bin based on the sum of the square root of the bin's rest capacity multiplied by the power of 4 raised to its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the rest capacities of the bins\\n sqrt_rest_capacities = np.sqrt(bins)\\n \\n # Calculate the powers of 4 for the indices of the bins\\n powers_of_4 = np.power(4, np.arange(len(bins)))\\n \\n # Multiply the square root rest capacities by the powers of 4\\n scores = sqrt_rest_capacities * powers_of_4\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+codellama7b/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: Assign bin scores by subtracting the bin capacity from the item capacity and multiplying the result by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on the item size and bin capacity\\n scores = (item - bins) * (np.arange(len(bins)) + 1)\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin by subtracting its square root multiplied by its index and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square root of the indices of the bins\\n sqrt_indices = np.sqrt(np.arange(len(bins)))\\n \\n # Subtract the square root multiplied by the item size from the rest capacities\\n scores = bins - (sqrt_indices * item)\\n \\n # Return the scores\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin by taking the ratio of its rest capacity to item size and subtracting the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Subtract the square root of the index from the ratios\\n scores = ratios - np.sqrt(np.arange(len(ratios)))\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the difference between the bin's rest capacity and the item's value, with a penalty for bins with a rest capacity smaller than a threshold.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = np.abs(item - bins)\\n \\n # Apply a penalty for bins with a rest capacity smaller than a threshold\\n penalties = np.where(diff < 50, 10 * (50 - diff), 0)\\n \\n # Calculate the scores for each bin\\n scores = diff + penalties\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by subtracting the item's size divided by the rest capacity multiplied by bin's capacity and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins - item) / (bins * (1 - item))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score for each bin is calculated as the multiplication of the ratio of the item to the rest capacity, the rest capacity and the exponential decay of the index. Score(bin) = (item / rest capacity) * rest capacity * exp(-index / number of bins).\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of the item to the rest capacity\\n ratio = item / (bins - 1)\\n \\n # Calculate the exponential decay of the index\\n decay = np.exp(-np.arange(len(bins)) / len(bins))\\n \\n # Multiply the ratio and the exponential decay to get the scores\\n scores = ratio * decay * bins\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New score function: Calculating the score as the difference between the logarithm of rest capacity and the bin index, multiplied by the ratio of item size to average bin size. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic rest capacity of each bin\\n log_rest_capacity = np.log(bins)\\n \\n # Calculate the ratio of item size to average bin size\\n item_size_ratio = item / np.mean(bins)\\n \\n # Calculate the score for each bin\\n scores = log_rest_capacity - item_size_ratio * (bins - item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will take into account the difference between the bin's rest capacity and the item's value, and a penalty for using bins with a rest capacity smaller than item's value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between the item's value and the bin's rest capacity\\n diff = item - bins\\n \\n # Penalize bins with a rest capacity smaller than the item's value\\n penalties = np.where(diff < 0, diff**2, 0)\\n \\n # Calculate the scores for each bin\\n scores = bins - penalties\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The item will be assigned to the bin with the maximum score by computing the difference between the bin's capacity and the item's size, and adding to the result the inverse of the square of the bin's index, multiplied by the cosine of the square of the rest capacity divided by the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Compute the difference between the bin's capacity and the item's size\\n diff = np.abs(bins - item)\\n \\n # Add the inverse of the square of the bin's index to the result\\n scores = diff + (np.arange(len(bins)) ** 2) / (item ** 2)\\n \\n # Multiply the scores by the cosine of the square of the rest capacity divided by the item's size\\n scores *= np.cos((bins - item) ** 2 / item)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Calculate scores for each bin by subtracting the bin's capacity from its index and returning a Numpy array of these scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin by subtracting the bin's capacity from its index\\n scores = np.subtract(np.arange(len(bins)), bins)\\n \\n # Return the scores for assignment\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the rest capacity and the product of the item and the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity for each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities * (1 / np.exp(-np.arange(len(rest_capacities)) ** 2))\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the rest capacity and the power of the item to the inverse exponential decay of the index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacities of the bins\\n rest_capacities = bins - item\\n \\n # Calculate the scores for each bin\\n scores = (rest_capacities ** (-np.arange(len(bins)) / len(bins))) * item\\n \\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins as the logarithm of the sum of rest capacity and the inverse of minimum capacity increment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the logarithmic score for each bin\\n scores = np.log(bins + item) / np.log(bins)\\n \\n # Add the inverse of the minimum capacity increment to the scores\\n scores += 1 / (np.min(bins) - item)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the sum of the rest capacity and an increasing linear function of the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity of each bin\\n rest_capacities = bins - item\\n \\n # Calculate the score for each bin\\n scores = rest_capacities + (np.arange(len(rest_capacities)) + 1) * item\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Score bins by multiplying their index by a weight and subtracting their capacity from the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin based on its index and weight\\n scores = (np.arange(len(bins)) * item) - bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assign a score to each bin by multiplying its capacity by its index, and then dividing the result by the item's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = (bins * item) / bins\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the item size by the percentage of the bin's capacity that is greater than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the score for each bin based on the item size and bin capacity\\n scores = (bins - item) / (bins * (1 - item / bins))\\n \\n # Return the scores as a NumPy array\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate scores based on a ratio between rest capacity and item size, penalized by the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity to item size for each bin\\n ratios = bins / item\\n \\n # Penalize bins with higher indices\\n penalties = np.arange(len(bins)) + 1\\n \\n # Calculate the total score for each bin\\n scores = ratios - penalties\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by calculating the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the bin's rest capacity divided by the product of the bin's index and the square of the item capacity\\n scores = (bins / (np.arange(len(bins)) + 1) ** 2) * item\\n \\n # Return the scores for the bins for assignment\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm will calculate the score of each bin based on a weighted sum of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of each bin based on a weighted sum of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of the bin number.\\n inv_num = 1 / np.arange(1, len(bins) + 1)\\n\\n # Calculate the normalized item size.\\n norm_item = item / np.max(bins)\\n\\n # Calculate the weighted sum of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\\n scores = inv_cap * inv_num * norm_item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the exponential of the sum of the bin index and the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-(bins - item))\\n scores[bins <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, but it penalizes the score of bins with a rest capacity less than the item size. The penalized modification is calculated as (bins - item) / (1 + np.arange(len(bins))) * (1 - min(bins / item, 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins))) * (1 - np.minimum(bins / item, 1))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: assigns an item to the bin with the best score, calculated as the sum of the inverse of the bin number and the product of the normalized capacity and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1)\\n scores = 1 / bin_nums + (bins / bins.max()) * (item / item.max())\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculate the score for each feasible bin as the product of using the bin and a weighted sum of the normalized capacity, the normalized item size, and the inverse of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the normalized capacity and item size.\\n cap_norm = bins / np.max(bins)\\n item_norm = item / np.max(bins)\\n\\n # Calculate the score as the product of using the bin, normalized capacity, normalized item size, and inverse of bin number.\\n scores = cap_norm * item_norm / (np.arange(len(bins)) + 1)\\n\\n # Adjust scores for bins with zero capacity.\\n scores[bins == 0] = -np.inf\\n\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the rest capacity and the normalized size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the multiplication of the rest capacity and the normalized size of the item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the normalized size of the item.\\n item_size_normalized = item / bins\\n\\n # Calculate the score for each bin.\\n scores = item_size_normalized * bins\\n\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin will be calculated based on a weighted sum of the current capacity and the difference between the maximum capacity and the current capacity, with a penalty for bins that reach the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * (1 - (bins - item).astype(bool)) - 1e9 * (bins <= item)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the difference between the square root of its rest capacity and the square root of its index, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) - np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.06711,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: The algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, but it multiplies the score by a penalty factor that is inversely proportional to the rest capacity to the power of a positive value (alpha) (1 + bins - item) * (bins - item) / (1 + np.arange(len(bins)))^alpha\",\n \"code\": \"def score(item, bins):\\n rest_capacity = np.array(bins) - item\\n pos_rest_cap = rest_capacity[rest_capacity > 0]\\n normalized_pos_rest_cap = pos_rest_cap / (1 + np.arange(len(pos_rest_cap)))\\n scores = (1 + pos_rest_cap) * normalized_pos_rest_cap ** 0.5\\n return scores\",\n \"objective\": 0.08804,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm score function: Divide the rest capacity of each bin by the size of the current item, subtract 2 if the rest capacity equals the maximum capacity, and set the score to 0 if the rest capacity is less than 2 times the item size.\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) / item\\n scores -= 2 * (bins == bins.max())\\n scores[bins < 2 * item] = 0\\n return scores\",\n \"objective\": 0.10414,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the product of its available capacity and a weight that decreases as the bin number increases.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of its available capacity and a weight that decreases as the bin number increases.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.ndarray): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the available capacity of each bin.\\n available_capacities = bins - item\\n\\n # Calculate the weight for each bin.\\n weights = 1 / np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = available_capacities * weights\\n\\n return scores\",\n \"objective\": 0.10746,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a bonus for bins that reach half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a bonus for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin as the inverse of the difference.\\n scores = 1 / diff\\n\\n # Add a bonus for bins that reach half of the maximum capacity.\\n max_capacity = np.max(bins)\\n half_max_capacity = max_capacity / 2\\n bonus = np.where(bins >= half_max_capacity, 1, 0)\\n scores += bonus\\n\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for a bin is computed as the product of the inverse of the square root of the rest capacity and the inverse of the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for a bin.\\n\\n The score is computed as the product of the inverse of the square root of the\\n rest capacity and the inverse of the square root of the bin number.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n rest_capacities = np.maximum(bins - item, 0)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = rest_capacities / np.sqrt(rest_capacities) * 1 / np.sqrt(bin_numbers)\\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at most three times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n # Penalize bins with remaining capacity less than half of the item size\\n scores[bins - item <= 0.5 * item] -= 0.5\\n # Mask out invalid bins (remaining capacity less than the item size)\\n scores[bins - item < 0] = -np.inf\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have smaller differences between their capacity and the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\\n scores[bins - item <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 5 times the item size, penalized if the remaining capacity is less than one third of the item size: scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= 1.0 / 3 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item. In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of\\n used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the score for each bin.\\n scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= 1.0 / 3 * item)\\n\\n # Handle the case where all bins have the same capacity.\\n if np.all(scores == scores[0]):\\n scores = np.ones(len(scores))\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 1.5 times the item size, penalized if the remaining capacity is less than 1/4 of the item size: scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.25 * (bins - item <= 0.25 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score. \\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are \\n larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities 1.5 times the item size, penalized\\n # if the remaining capacity is less than 1/4 of the item size.\\n scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.25 * (bins - item <= 0.25 * item)\\n if np.max(scores) >= 0 and scores.size > 0:\\n # Normalize scores to [0, 1].\\n scores = scores / np.max(scores)\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 30% of the item size, penalized if the remaining capacity is less than 10% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.3 * item) - 0.1 * (bins - item <= 0.1 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.3 * item) - 0.1 * (bins - item <= 0.1 * item)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 15% of the item size, penalized if the remaining capacity is less than 5% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.15 * item) - 0.05 * (bins - item <= 0.05 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Prioritize bins that have capacities within 15% of the item size, penalized if the remaining capacity is less than 5% of the item size.\\n \\n Args:\\n item: Size of the current item to be assigned. (int)\\n bins: Rest capacities of feasible bins, which are larger than the item size. (np.ndarray)\\n \\n Returns:\\n Scores for the bins for assignment. (np.ndarray)\\n \\\"\\\"\\\"\\n\\n # Penalize bins with less than 5% remaining capacity\\n penalty = np.where(bins - item <= 0.05 * item, -0.05, 0.0)\\n\\n # Calculate scores\\n scores = 1.0 / (bins - item) * np.where(np.abs(bins - item) <= 0.15 * item, 1.0, 0.0) + penalty\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that are at most n times the size of the item and penalize bins with less than k times the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Prioritize bins that are at most n times the size of the item\\n n = 2\\n scores = np.where(bins <= n * item, bins / item, 0)\\n\\n # Penalize bins with less than k times the remaining capacity\\n k = 0.5\\n remaining_capacity = bins - item\\n scores = np.where(remaining_capacity >= k * bins, scores, scores / remaining_capacity)\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities within 20% of the item size, penalized if the remaining capacity is less than 10% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\",\n \"code\": \"def score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Prioritize bins that have capacities within 20% of the item size, penalized if the remaining capacity is less than 10% of the item size:\\n scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\\n \\\"\\\"\\\"\\n assert np.all(bins >= item), \\\"Bins must have sufficient capacity to accommodate the item\\\"\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"**Combine the idea of using the inverse of the difference between the bin capacity and the item size with the idea of prioritizing bins that have capacities within 20% of the item size.**\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the difference between the bin capacity and the item size\\n inv_diffs = 1 / np.maximum(bins - item, 1)\\n \\n # Calculate the priority factor for bins within 20% of the item size\\n priorities = np.where(np.abs(bins - item) <= (item * 0.2), 1, 0)\\n \\n # Combine the inverse differences and priorities\\n scores = inv_diffs * priorities\\n \\n # Normalize the scores to avoid overflow\\n scores = scores / np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigning an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square of the inverse of the bin number, and a constant \\\"k\\\". Scores are multiplied by k if the bin's remaining capacity is less than the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / bins\\n\\n # Compute the square of the inverse of the bin number.\\n inv_bin_num_sq = 1.0 / np.arange(1, len(bins) + 1) ** 2\\n\\n # Compute the score for each bin.\\n scores = inv_cap + inv_bin_num_sq + np.log(bins/(bins-item))\\n\\n # Multiply the score by a constant if the bin's remaining capacity is less than the item's size.\\n scores[bins < item] *= 100\\n\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a bonus for bins that reach half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a bonus for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin as the inverse of the difference.\\n scores = 1 / diff\\n\\n # Add a bonus for bins that reach half of the maximum capacity.\\n max_capacity = np.max(bins)\\n half_max_capacity = max_capacity / 2\\n bonus = np.where(bins >= half_max_capacity, 1, 0)\\n scores += bonus\\n\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for a bin is computed as the product of the inverse of the square root of the rest capacity and the inverse of the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for a bin.\\n\\n The score is computed as the product of the inverse of the square root of the\\n rest capacity and the inverse of the square root of the bin number.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n rest_capacities = np.maximum(bins - item, 0)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = rest_capacities / np.sqrt(rest_capacities) * 1 / np.sqrt(bin_numbers)\\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at most three times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n # Penalize bins with remaining capacity less than half of the item size\\n scores[bins - item <= 0.5 * item] -= 0.5\\n # Mask out invalid bins (remaining capacity less than the item size)\\n scores[bins - item < 0] = -np.inf\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have smaller differences between their capacity and the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\\n scores[bins - item <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 1.5 times the item size, penalized if the remaining capacity is less than a third of the item size: scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.3 * (bins - item <= 0.33 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n \\n scores = 1.0 / (bins - item)\\n scores *= bins <= 1.5 * item\\n scores -= 0.3 * (bins - item <= 0.33 * item)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 5 times the item size, penalized if the remaining capacity is less than one third of the item size: scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= 1.0 / 3 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item. In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of\\n used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the score for each bin.\\n scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= 1.0 / 3 * item)\\n\\n # Handle the case where all bins have the same capacity.\\n if np.all(scores == scores[0]):\\n scores = np.ones(len(scores))\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 30% of the item size, penalized if the remaining capacity is less than 20% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.3 * item) - 0.2 * (bins - item <= 0.2 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.3 * item) - 0.2 * (bins - item <= 0.2 * item)\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 1.5 times the item size, penalized if the remaining capacity is less than 1/4 of the item size: scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.25 * (bins - item <= 0.25 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score. \\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are \\n larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities 1.5 times the item size, penalized\\n # if the remaining capacity is less than 1/4 of the item size.\\n scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.25 * (bins - item <= 0.25 * item)\\n if np.max(scores) >= 0 and scores.size > 0:\\n # Normalize scores to [0, 1].\\n scores = scores / np.max(scores)\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 30% of the item size, penalized if the remaining capacity is less than 10% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.3 * item) - 0.1 * (bins - item <= 0.1 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.3 * item) - 0.1 * (bins - item <= 0.1 * item)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 15% of the item size, penalized if the remaining capacity is less than 5% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.15 * item) - 0.05 * (bins - item <= 0.05 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Prioritize bins that have capacities within 15% of the item size, penalized if the remaining capacity is less than 5% of the item size.\\n \\n Args:\\n item: Size of the current item to be assigned. (int)\\n bins: Rest capacities of feasible bins, which are larger than the item size. (np.ndarray)\\n \\n Returns:\\n Scores for the bins for assignment. (np.ndarray)\\n \\\"\\\"\\\"\\n\\n # Penalize bins with less than 5% remaining capacity\\n penalty = np.where(bins - item <= 0.05 * item, -0.05, 0.0)\\n\\n # Calculate scores\\n scores = 1.0 / (bins - item) * np.where(np.abs(bins - item) <= 0.15 * item, 1.0, 0.0) + penalty\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a bonus for bins that reach half of the maximum capacity. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a bonus for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin as the inverse of the difference.\\n scores = 1 / diff\\n\\n # Add a bonus for bins that reach half of the maximum capacity.\\n max_capacity = np.max(bins)\\n half_max_capacity = max_capacity / 2\\n bonus = np.where(bins >= half_max_capacity, 1, 0)\\n scores += bonus\\n\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for a bin is computed as the product of the inverse of the square root of the rest capacity and the inverse of the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for a bin.\\n\\n The score is computed as the product of the inverse of the square root of the\\n rest capacity and the inverse of the square root of the bin number.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n rest_capacities = np.maximum(bins - item, 0)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = rest_capacities / np.sqrt(rest_capacities) * 1 / np.sqrt(bin_numbers)\\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at most three times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n # Penalize bins with remaining capacity less than half of the item size\\n scores[bins - item <= 0.5 * item] -= 0.5\\n # Mask out invalid bins (remaining capacity less than the item size)\\n scores[bins - item < 0] = -np.inf\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have smaller differences between their capacity and the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\\n scores[bins - item <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 1.5 times the item size, penalized if the remaining capacity is less than a third of the item size: scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.3 * (bins - item <= 0.33 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n \\n scores = 1.0 / (bins - item)\\n scores *= bins <= 1.5 * item\\n scores -= 0.3 * (bins - item <= 0.33 * item)\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 5 times the item size, penalized if the remaining capacity is less than one third of the item size: scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= 1.0 / 3 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item. In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of\\n used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the score for each bin.\\n scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= 1.0 / 3 * item)\\n\\n # Handle the case where all bins have the same capacity.\\n if np.all(scores == scores[0]):\\n scores = np.ones(len(scores))\\n\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 30% of the item size, penalized if the remaining capacity is less than 20% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.3 * item) - 0.2 * (bins - item <= 0.2 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.3 * item) - 0.2 * (bins - item <= 0.2 * item)\\n return scores\",\n \"objective\": 0.03693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone is prioritizing bins based on their remaining capacity relative to the item size, with penalties for bins with smaller remaining capacity. New algorithm: Prioritize bins that have capacities 1.5 times the item size, penalized if the remaining capacity is less than one quarter of the item size: scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.25 * (bins - item <= 0.25 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 1.5 * item) - 0.25 * (bins - item <= 0.25 * item)\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins by dividing the square root of the item size by the difference between the bin size and the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n '''\\n Score bins by dividing the square root of the item size by the difference between the bin size and the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than three times the item size.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n '''\\n\\n scores = np.sqrt(item) / (bins - item)\\n scores[bins - item < item / 2] -= 1\\n scores[bins - item > item * 3] += 1\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins based on the sum of the square of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\\n\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 4 times the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities twice the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\\n scores = np.where(bins < item, -np.inf, scores) # Penalize bins that are too small\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by dividing the square root of the item size by the difference between the bin size and the item size and penalize if the remaining capacity is less than one fourth of the item size and bonus if the remaining capacity is larger than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / (bins - item)\\n scores[bins - item < item / 4] -= 1\\n scores[bins - item > item * 2] += 1\\n return scores\",\n \"objective\": 0.02314,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins that have capacities twice the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than five times the item size: \\nscores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 1.0 / 2 * item) + 0.5 * (bins - item >= 5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Score bins that have capacities twice the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than five times the item size: \\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 1.0 / 2 * item) + 0.5 * (bins - item >= 5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item) + 0.5 * (bins - item >= 5 * item)\\n return scores\",\n \"objective\": 0.02374,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for a bin is computed as the product of the inverse of the square root of the rest capacity and the inverse of the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for a bin.\\n\\n The score is computed as the product of the inverse of the square root of the\\n rest capacity and the inverse of the square root of the bin number.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n rest_capacities = np.maximum(bins - item, 0)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = rest_capacities / np.sqrt(rest_capacities) * 1 / np.sqrt(bin_numbers)\\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at most three times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n # Penalize bins with remaining capacity less than half of the item size\\n scores[bins - item <= 0.5 * item] -= 0.5\\n # Mask out invalid bins (remaining capacity less than the item size)\\n scores[bins - item < 0] = -np.inf\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with an item size larger than half of the remaining capacity: scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (item > 0.5 * bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins = bins[bins >= item]\\n scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (item > 0.5 * bins)\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.02596,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins based on the sum of the square of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\\n\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 4 times the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities twice the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\\n scores = np.where(bins < item, -np.inf, scores) # Penalize bins that are too small\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by dividing the square root of the item size by the difference between the bin size and the item size and penalize if the remaining capacity is less than one fourth of the item size and bonus if the remaining capacity is larger than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / (bins - item)\\n scores[bins - item < item / 4] -= 1\\n scores[bins - item > item * 2] += 1\\n return scores\",\n \"objective\": 0.02314,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins that have capacities twice the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than five times the item size: \\nscores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 1.0 / 2 * item) + 0.5 * (bins - item >= 5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Score bins that have capacities twice the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than five times the item size: \\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 1.0 / 2 * item) + 0.5 * (bins - item >= 5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item) + 0.5 * (bins - item >= 5 * item)\\n return scores\",\n \"objective\": 0.02374,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for a bin is computed as the product of the inverse of the square root of the rest capacity and the inverse of the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for a bin.\\n\\n The score is computed as the product of the inverse of the square root of the\\n rest capacity and the inverse of the square root of the bin number.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n rest_capacities = np.maximum(bins - item, 0)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = rest_capacities / np.sqrt(rest_capacities) * 1 / np.sqrt(bin_numbers)\\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at most three times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n # Penalize bins with remaining capacity less than half of the item size\\n scores[bins - item <= 0.5 * item] -= 0.5\\n # Mask out invalid bins (remaining capacity less than the item size)\\n scores[bins - item < 0] = -np.inf\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with an item size larger than half of the remaining capacity: scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (item > 0.5 * bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins = bins[bins >= item]\\n scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (item > 0.5 * bins)\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins based on the sum of the square of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\\n\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 4 times the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities twice the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\\n scores = np.where(bins < item, -np.inf, scores) # Penalize bins that are too small\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 5 times the item size, with a minimum score of 0.3 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Prioritize bins that have capacities 5 times the item size, with a minimum score of 0.3 if the remaining capacity is less than the item size:\\n scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02254,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by dividing the square root of the item size by the difference between the bin size and the item size and penalize if the remaining capacity is less than one fourth of the item size and bonus if the remaining capacity is larger than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / (bins - item)\\n scores[bins - item < item / 4] -= 1\\n scores[bins - item > item * 2] += 1\\n return scores\",\n \"objective\": 0.02314,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins that have capacities twice the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than five times the item size: \\nscores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 1.0 / 2 * item) + 0.5 * (bins - item >= 5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Score bins that have capacities twice the item size and penalize if the remaining capacity is less than one half of the item size and bonus if the remaining capacity is larger than five times the item size: \\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 1.0 / 2 * item) + 0.5 * (bins - item >= 5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item) + 0.5 * (bins - item >= 5 * item)\\n return scores\",\n \"objective\": 0.02374,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for a bin is computed as the product of the inverse of the square root of the rest capacity and the inverse of the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for a bin.\\n\\n The score is computed as the product of the inverse of the square root of the\\n rest capacity and the inverse of the square root of the bin number.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n rest_capacities = np.maximum(bins - item, 0)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = rest_capacities / np.sqrt(rest_capacities) * 1 / np.sqrt(bin_numbers)\\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the square of the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculate the score of each bin for assigning an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize the capacity to be full, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.35 * (bins - item > 0) + 0.45 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 4 times the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities twice the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\\n scores = np.where(bins < item, -np.inf, scores) # Penalize bins that are too small\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 5 times the item size, with a minimum score of 0.3 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Prioritize bins that have capacities 5 times the item size, with a minimum score of 0.3 if the remaining capacity is less than the item size:\\n scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 5 * item) - 0.3 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02254,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by dividing the square root of the item size by the difference between the bin size and the item size and penalize if the remaining capacity is less than one fourth of the item size and bonus if the remaining capacity is larger than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / (bins - item)\\n scores[bins - item < item / 4] -= 1\\n scores[bins - item > item * 2] += 1\\n return scores\",\n \"objective\": 0.02314,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the square of the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculate the score of each bin for assigning an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize the capacity to be full, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.35 * (bins - item > 0) + 0.45 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 4 times the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities twice the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\\n scores = np.where(bins < item, -np.inf, scores) # Penalize bins that are too small\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size, and have a sigmoid penalty for bins with capacity smaller than the item size: scores = ((1 + np.exp(-(bins - item) / 5)) + np.exp(-(bins - item) / 2) - 1) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\",\n \"code\": \"def score(item, bins):\\n scores = ((1 + np.exp(-(bins - item) / 5)) + np.exp(-(bins - item) / 2) - 1) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.02173,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have zero remaining capacity after placing the item, penalized if the bin capacity is less than 2 times the item size: Score = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between a given factor a and b times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (item <= bins) - 0.4 * (bins - item <= 0.5 * item)\\n scores[bins < item] = -1e10\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the square of the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculate the score of each bin for assigning an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize the capacity to be full, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.35 * (bins - item > 0) + 0.45 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 4 times the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 4 * item) - 0.5 * (bins - item <= item)\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities twice the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.5 * (bins - item <= 0.5 * item)\\n scores = np.where(bins < item, -np.inf, scores) # Penalize bins that are too small\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity but also with a higher weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum(bins - item, 1e-9) # Inverse difference between capacity and item size\\n penalty = (bins < 0.5 * np.max(bins)) & (bins > 0) # Penalty for bins with less than half capacity\\n weight = np.log10(np.maximum(bins - item, 1e-9))\\n scores[penalty] -= weight[penalty]\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have zero remaining capacity after placing the item, penalized if the bin capacity is less than 2 times the item size: Score = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between a given factor a and b times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (item <= bins) - 0.4 * (bins - item <= 0.5 * item)\\n scores[bins < item] = -1e10\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the square of the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculate the score of each bin for assigning an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize the capacity to be full, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.35 * (bins - item > 0) + 0.45 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score of each bin based on a weighted sum of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of each bin based on a weighted sum of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of the bin number.\\n inv_num = 1 / np.arange(1, len(bins) + 1)\\n\\n # Calculate the normalized item size.\\n norm_item = item / np.max(bins)\\n\\n # Calculate the weighted sum of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\\n scores = inv_cap * inv_num * norm_item\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights for the rest capacity and the inverse of the index.\\n weights = np.where(diff >= 0, 1 / diff, 0)\\n\\n # Compute the score for each bin.\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the exponential of the sum of the bin index and the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-(bins - item))\\n scores[bins <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A variant form of the provided algorithm, where the score is computed as the sum of the inverse of the bin number and the inverse of the bin's remaining capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / np.arange(1, bins.size + 1) + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the bin's index with the exponential of the rest capacity, then add the item size to the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the multiplication of the bin's index with the exponential of the rest capacity, then add the item size to the result.\\n\\n Args:\\n item: the size of current item\\n bins: the rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n scores: the scores for the bins for assignment\\n \\\"\\\"\\\"\\n scores = bins * np.exp(-bins) + item\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, but it penalizes the score of bins with a rest capacity less than the item size. The penalized modification is calculated as (bins - item) / (1 + np.arange(len(bins))) * (1 - min(bins / item, 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins))) * (1 - np.minimum(bins / item, 1))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New Algorithm: Adjust the score function by weight the score based on rest capacity of bins. The score is calculated as scores = (bins + weight) / np.maximum((bins - item), 1)}\",\n \"code\": \"def score(item, bins):\\n scores = (bins + (1 + bins - item) / 2) / np.maximum((bins - item), 1)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score of a bin based on the rest capacity divided by the bin index, with a penalty added for bins with a rest capacity less than twice the item size.\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 * bins / np.arange(1, len(bins) + 1)\\n # Penalize for nearly full bins\\n nearly_full_bins = (bins <= 2 * item)\\n full_penalty = 0.001\\n scores[nearly_full_bins] -= full_penalty\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: assigns an item to the bin with the best score, calculated as the sum of the inverse of the bin number and the product of the normalized capacity and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1)\\n scores = 1 / bin_nums + (bins / bins.max()) * (item / item.max())\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score of each bin based on the product of the normalized available capacity and the inverse of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if bins.min() < item:\\n return np.zeros_like(bins)\\n \\n normalized_available_capacity = bins / bins.max()\\n inverse_bin_number = 1.0 / np.arange(1, bins.size + 1)\\n scores = normalized_available_capacity * inverse_bin_number\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the multiplication of the rest capacity and the normalized size of the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the multiplication of the rest capacity and the normalized size of the item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the normalized size of the item.\\n item_size_normalized = item / bins\\n\\n # Calculate the score for each bin.\\n scores = item_size_normalized * bins\\n\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item)\\n scores[bins <= item] = -np.inf\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin will be calculated based on a weighted sum of the current capacity and the difference between the maximum capacity and the current capacity, with a penalty for bins that reach the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * (1 - (bins - item).astype(bool)) - 1e9 * (bins <= item)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins by the product of the available capacity and its reciprocal, and set the score to -1 if the bin is full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (1 / bins)\\n scores[bins == 0] = -1\\n return scores\",\n \"objective\": 0.05695,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the difference between the square root of its rest capacity and the square root of its index, and returns the scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) - np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.06711,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity but also with a higher weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum(bins - item, 1e-9) # Inverse difference between capacity and item size\\n penalty = (bins < 0.5 * np.max(bins)) & (bins > 0) # Penalty for bins with less than half capacity\\n weight = np.log10(np.maximum(bins - item, 1e-9))\\n scores[penalty] -= weight[penalty]\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the difference between the remaining capacity and the item size (with a higher penalty for bins with a smaller remaining capacity): scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have zero remaining capacity after placing the item, penalized if the bin capacity is less than 2 times the item size: Score = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between a given factor a and b times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (item <= bins) - 0.4 * (bins - item <= 0.5 * item)\\n scores[bins < item] = -1e10\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New Algorithm: Prioritize bins that have capacities between 2.5 and 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (2.5 * item <= bins <= 3 * item) - 0.5 * (bins - item <= 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * ((2.5 * item <= bins) & (bins <= 3 * item)) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the square of the inverse of the remaining capacity and the square of the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculate the score of each bin for assigning an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item)**2 + 1.0 / item**2 - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm with a focus on penalizing bins with remaining capacities under a certain threshold: score = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with capacities between a given factor a and b times the item size, and penalize bins if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score a set of bins to assign an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n a = 0.7\\n b = 1.3\\n scores = 1.0 / (bins - item) * (a * item <= bins) * (bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity but also with a higher weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum(bins - item, 1e-9) # Inverse difference between capacity and item size\\n penalty = (bins < 0.5 * np.max(bins)) & (bins > 0) # Penalty for bins with less than half capacity\\n weight = np.log10(np.maximum(bins - item, 1e-9))\\n scores[penalty] -= weight[penalty]\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the difference between the remaining capacity and the item size (with a higher penalty for bins with a smaller remaining capacity): scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have zero remaining capacity after placing the item, penalized if the bin capacity is less than 2 times the item size: Score = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between a given factor a and b times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (item <= bins) - 0.4 * (bins - item <= 0.5 * item)\\n scores[bins < item] = -1e10\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Computes a score for each bin based on the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the difference.\\n reciprocal = 1.0 / diff\\n\\n # Calculate the penalty for bins with smaller remaining capacity.\\n penalty = np.where(diff <= 0.5 * bins, 1.0, 0.0)\\n\\n # Calculate the score for each bin.\\n scores = reciprocal - penalty\\n\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at least 3 times the item size, with a minimum score of 0.5 if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm with a focus on penalizing bins with remaining capacities under a certain threshold: score = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with capacities between a given factor a and b times the item size, and penalize bins if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score a set of bins to assign an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n a = 0.7\\n b = 1.3\\n scores = 1.0 / (bins - item) * (a * item <= bins) * (bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity but also with a higher weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum(bins - item, 1e-9) # Inverse difference between capacity and item size\\n penalty = (bins < 0.5 * np.max(bins)) & (bins > 0) # Penalty for bins with less than half capacity\\n weight = np.log10(np.maximum(bins - item, 1e-9))\\n scores[penalty] -= weight[penalty]\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the difference between the remaining capacity and the item size (with a higher penalty for bins with a smaller remaining capacity): scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have zero remaining capacity after placing the item, penalized if the bin capacity is less than 2 times the item size: Score = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between a given factor a and b times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (item <= bins) - 0.4 * (bins - item <= 0.5 * item)\\n scores[bins < item] = -1e10\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item > 0) + 0.35 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at least 3 times the item size, with a minimum score of 0.5 if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm with a focus on penalizing bins with remaining capacities under a certain threshold: score = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Prioritize bins that have capacities less than 1.5 times the item size, penalized if the remaining capacity is less than 0.5 times the item size: scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item < 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n item = float(item)\\n bins = bins[bins >= item].copy() # Remove bins that cannot accommodate the item\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with capacities between a given factor a and b times the item size, and penalize bins if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score a set of bins to assign an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n a = 0.7\\n b = 1.3\\n scores = 1.0 / (bins - item) * (a * item <= bins) * (bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity but also with a higher weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum(bins - item, 1e-9) # Inverse difference between capacity and item size\\n penalty = (bins < 0.5 * np.max(bins)) & (bins > 0) # Penalty for bins with less than half capacity\\n weight = np.log10(np.maximum(bins - item, 1e-9))\\n scores[penalty] -= weight[penalty]\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the difference between the remaining capacity and the item size (with a higher penalty for bins with a smaller remaining capacity): scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have zero remaining capacity after placing the item, penalized if the bin capacity is less than 2 times the item size: Score = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between a given factor a and b times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (item <= bins) - 0.4 * (bins - item <= 0.5 * item)\\n scores[bins < item] = -1e10\\n return scores\",\n \"objective\": 0.01781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities less than twice the item size, penalized if the remaining capacity is less than half of the item size and penalized if the remaining capacity is more than 0.25 times the item size: score = 1.0 / (bins - item) * (bins < 2 * item) - 0.4 * (bins - item <= 0.5 * item) + 0.2 * (0.25 * item <= bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n feas_bins = bins[bins >= item]\\n \\n score1 = 1.0 / (feas_bins - item)\\n score1[feas_bins >= 2*item] = 0\\n\\n score2 = -0.4 * (feas_bins - item <= 0.5*item)\\n\\n score3 = 0.2 * (0.25*item <= feas_bins - item) * (feas_bins - item <= 0.5*item)\\n\\n scores = score1 + score2 + score3\\n\\n return scores\",\n \"objective\": 0.01791,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at least 3 times the item size, with a minimum score of 0.5 if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with remaining capacities under a threshold (0.75) : score = 1.0 / (bins - item) * (bins < 1.6 * item) - 0.75 * (bins - item <= 0.75 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / (bins - item) * (bins < 1.6 * item) - 0.75 * (bins - item <= 0.75 * item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm with a focus on penalizing bins with remaining capacities under a certain threshold: score = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Prioritize bins that have capacities less than 1.5 times the item size, penalized if the remaining capacity is less than 0.5 times the item size: scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item < 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n item = float(item)\\n bins = bins[bins >= item].copy() # Remove bins that cannot accommodate the item\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have their maximal capacity less than the given factor a times the item size, penalized if the remaining capacity is less than half the item size: score = 1.0 / (bin - item) * (bin <= a * item) - 0.4 * (bin - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= item*1.2) - 0.4 * (bins - item <= 0.5 * item)\\n if item > bins.max():\\n scores[:] = -float('inf')\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins with capacities between a given factor a and b times the item size, and penalize bins if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (a * item <= bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score a set of bins to assign an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n a = 0.7\\n b = 1.3\\n scores = 1.0 / (bins - item) * (a * item <= bins) * (bins <= b * item) - 0.8 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity but also with a higher weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum(bins - item, 1e-9) # Inverse difference between capacity and item size\\n penalty = (bins < 0.5 * np.max(bins)) & (bins > 0) # Penalty for bins with less than half capacity\\n weight = np.log10(np.maximum(bins - item, 1e-9))\\n scores[penalty] -= weight[penalty]\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the difference between the remaining capacity and the item size (with a higher penalty for bins with a smaller remaining capacity): scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have zero remaining capacity after placing the item, penalized if the bin capacity is less than 2 times the item size: Score = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins - item == 0) - 0.2 * (bins < 2 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at least 3 times the item size, with a minimum score of 0.5 if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins >= 3 * item) - 0.5 * (bins - item <= item/2)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with remaining capacities under a threshold (0.75) : score = 1.0 / (bins - item) * (bins < 1.6 * item) - 0.75 * (bins - item <= 0.75 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / (bins - item) * (bins < 1.6 * item) - 0.75 * (bins - item <= 0.75 * item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the reciprocal of the difference between the bin capacity and the item size and a penalty for bins that have reached half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n zeros = np.zeros_like(bins)\\n penalties = np.where(bins > (bins.max() // 2), zeros, 10000)\\n scores = 1.0 / np.maximum(bins - item, zeros) - penalties\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm with a focus on penalizing bins with remaining capacities under a certain threshold: score = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Prioritize bins that have capacities less than 1.5 times the item size, penalized if the remaining capacity is less than 0.5 times the item size: scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item < 0.5 * item) \",\n \"code\": \"def score(item, bins):\\n item = float(item)\\n bins = bins[bins >= item].copy() # Remove bins that cannot accommodate the item\\n scores = 1.0 / (bins - item) * (bins < 1.5 * item) - 0.5 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / (bins - item)\\n penalty = (bins < bins.max() / 2)\\n scores[penalty] -= 1000\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have their maximal capacity less than the given factor a times the item size, penalized if the remaining capacity is less than half the item size: score = 1.0 / (bin - item) * (bin <= a * item) - 0.4 * (bin - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= item*1.2) - 0.4 * (bins - item <= 0.5 * item)\\n if item > bins.max():\\n scores[:] = -float('inf')\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, with a minimum score of 0.75 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.75 * (bins - item <= item)\\n scores[bins < item] = -1e9\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm penalizes bins with remaining capacities under a threshold (0.5) : score = 1.0 / (bins - item) * (bins < 1.3 * item) - 0.75 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1.0 / (bins - item)\\n threshold = 0.5 * item\\n scores *= (bins < 1.3 * item)\\n scores -= 0.75 * (bins - item <= threshold)\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, and then apply a penalty to bins that have a rest capacity that is less than half of the maximum capacity but also with a higher weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum(bins - item, 1e-9) # Inverse difference between capacity and item size\\n penalty = (bins < 0.5 * np.max(bins)) & (bins > 0) # Penalty for bins with less than half capacity\\n weight = np.log10(np.maximum(bins - item, 1e-9))\\n scores[penalty] -= weight[penalty]\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Prioritize bins that have capacities equal to the item size, with a minimum score of 0.5 if the remaining capacity is less than the item size: scores = 1.0 / (bins - item) * (bins == item) - 0.5 * (bins - item <= item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins that have capacities equal to the item size.\\n scores = 1.0 / (bins - item) * (bins == item)\\n\\n # Penalize bins that have less remaining capacity than the item size.\\n scores -= 0.5 * (bins - item <= item)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Penalize a bin's capacity to be full, but have a lower penalty than the first algorithm, prioritize bins with capacity greater than the item size: scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.1 * (bins - item > 0) + 0.3 * (bins - item > (item / 2))\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the difference between the remaining capacity and the item size (with a higher penalty for bins with a smaller remaining capacity): scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item) - 0.1 * (bins - item < 0.25 * item)\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities greater than the item size and penalized if the remaining capacity is less than half of the item size: score = 2.0 / (bin - item) * (bin > item) - 0.5 * (bin - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 2.0 / (bins - item) * (bins > item) - 0.5 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 7 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 7 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin for item assignment.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n scores: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Prioritize bins with enough capacity to fit the item.\\n scores = np.where(bins >= item, 1.0 / (bins - item), 0.0)\\n\\n # Penalize bins that are nearly full.\\n scores -= 0.2 * np.where(bins - item <= 0.5 * item, 1.0, 0.0)\\n\\n # Penalize bins that are too big.\\n scores *= np.where(bins <= 7 * item, 1.0, 0.0)\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with larger remaining capacity: scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) + 0.2 * (bins - item > 0.5 * item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities 3 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities between half and 2 times the item size, penalized if the remaining capacity is less than half of the item size: score = 1.0 / (bins - item) * (0.5 * item <= bins <= 2 * item) - 0.4 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin factor\\n bins_factor = 1.0 / (bins - item)\\n\\n # Calculate the bin capacity range\\n lower_capacity_bound = 0.5 * item\\n upper_capacity_bound = 2 * item\\n\\n # Calculate the bin capacity range score\\n capacity_range_score = (0.5 * item <= bins) * (bins <= 2 * item)\\n\\n # Calculate the bin remaining capacity score\\n remaining_capacity_score = -0.4 * (bins - item <= 0.5 * item)\\n\\n # Calculate the final score\\n scores = bins_factor * capacity_range_score + remaining_capacity_score\\n\\n return scores\",\n \"objective\": 0.01741,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the score as a normalized linear function of the bin index plus the rest capacity divided by the normalized bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Normalize the bin indices and the remaining capacities.\\n normalized_bin_indices = (bins - item) / bins\\n normalized_remaining_capacities = bins / (bins - item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_bin_indices * normalized_remaining_capacities\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score of each bin based on a product of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score of each bin for assignment.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n normalized_item_size = item / np.max(bins)\\n scores = 1 / available_capacity * 1 / bin_number * normalized_item_size\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights for the rest capacity and the inverse of the index.\\n weights = np.where(diff >= 0, 1 / diff, 0)\\n\\n # Compute the score for each bin.\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Use the inverse of available capacity, the square root of the inverse of the bin number, and the square root of normalized item size, all multiplied together to score bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n item_size = item / bins\\n scores = (1 / available_capacity) * np.sqrt(1 / bin_number) * np.sqrt(item_size)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin as the sum of the multiplication of the inverse of the available capacity and the bin number, and the subtraction of the available capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 / bins - bins + item \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A variant form of the provided algorithm, where the score is computed as the sum of the inverse of the bin number and the inverse of the bin's remaining capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / np.arange(1, bins.size + 1) + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm will calculate the score of each bin based on a product of the inverse of the available capacity, the square of the inverse of the bin number, and the square of the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity\\n inv_cap = 1.0 / (bins - item)\\n\\n # Calculate the square of the inverse of the bin number\\n inv_bin_num_sq = np.square(1.0 / np.arange(1, len(bins) + 1))\\n\\n # Calculate the square of the normalized item size\\n norm_item_size_sq = np.square(item / bins)\\n\\n # Calculate the scores\\n scores = inv_cap * inv_bin_num_sq * norm_item_size_sq\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\\n\\n Args:\\n item (int): The size of current item.\\n bins (np.ndarray): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Inverse of the available capacity\\n inv_cap = 1 / (bins - item)\\n\\n # Bin number\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Normalized item size\\n norm_item = item / bins\\n\\n # Calculate the scores\\n scores = inv_cap + bin_num + norm_item\\n\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the difference between the maximum capacity and the available capacity, divided by the difference between the item size and the available capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.zeros_like(bins, dtype=np.float64)\\n feasible = bins >= item\\n scores[feasible] = (bins[feasible] - item) / (bins[feasible] - item)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, but it penalizes the score of bins with a rest capacity less than the item size. The penalized modification is calculated as (bins - item) / (1 + np.arange(len(bins))) * (1 - min(bins / item, 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins))) * (1 - np.minimum(bins / item, 1))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n rest_capacity = max_capacity - bins\\n bin_number = np.arange(len(rest_capacity)) + 1\\n scores = 0.8 * rest_capacity / max_capacity + 0.2 / bin_number\\n scores[rest_capacity < item] = -1\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the product of the inverse of the available capacity, the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n bins_suit = bins[bins >= item]\\n if len(bins_suit) <= 0:\\n return np.zeros(len(bins))\\n item_normalized = item / np.max(bins_suit)\\n scores = 1 / bins_suit * bins_suit + item_normalized\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Adjust the score function by weight the score based on the square root of the rest capacity of bins. The score is calculated as scores = (bins + sqrt(bins)) / np.maximum((bins - item), 1)\",\n \"code\": \"def score(item, bins):\\n scores = (bins + np.sqrt(bins)) / np.maximum((bins - item), 1)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score of a bin based on the rest capacity divided by the bin index, with a penalty added for bins with a rest capacity less than twice the item size.\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 * bins / np.arange(1, len(bins) + 1)\\n # Penalize for nearly full bins\\n nearly_full_bins = (bins <= 2 * item)\\n full_penalty = 0.001\\n scores[nearly_full_bins] -= full_penalty\\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: assigns an item to the bin with the best score, calculated as the sum of the inverse of the bin number and the product of the normalized capacity and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_nums = np.arange(1, len(bins) + 1)\\n scores = 1 / bin_nums + (bins / bins.max()) * (item / item.max())\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score of each bin based on the product of the normalized available capacity and the inverse of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if bins.min() < item:\\n return np.zeros_like(bins)\\n \\n normalized_available_capacity = bins / bins.max()\\n inverse_bin_number = 1.0 / np.arange(1, bins.size + 1)\\n scores = normalized_available_capacity * inverse_bin_number\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the bin index divided by the square root of the difference between the bin capacity and the item size, with a penalty if the bin is full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.astype(np.float64) / np.sqrt(bins - item)) * (bins != 0)\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the score as a normalized linear function of the bin index plus the rest capacity divided by the normalized bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Normalize the bin indices and the remaining capacities.\\n normalized_bin_indices = (bins - item) / bins\\n normalized_remaining_capacities = bins / (bins - item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_bin_indices * normalized_remaining_capacities\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigning an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square of the inverse of the bin number, and a constant \\\"k\\\". Scores are multiplied by k if the bin's remaining capacity is less than the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / bins\\n\\n # Compute the square of the inverse of the bin number.\\n inv_bin_num_sq = 1.0 / np.arange(1, len(bins) + 1) ** 2\\n\\n # Compute the score for each bin.\\n scores = inv_cap + inv_bin_num_sq + np.log(bins/(bins-item))\\n\\n # Multiply the score by a constant if the bin's remaining capacity is less than the item's size.\\n scores[bins < item] *= 100\\n\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score of each bin based on a product of the inverse of the available capacity, the inverse of the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score of each bin for assignment.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n normalized_item_size = item / np.max(bins)\\n scores = 1 / available_capacity * 1 / bin_number * normalized_item_size\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights for the rest capacity and the inverse of the index.\\n weights = np.where(diff >= 0, 1 / diff, 0)\\n\\n # Compute the score for each bin.\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Use the inverse of available capacity, the square root of the inverse of the bin number, and the square root of normalized item size, all multiplied together to score bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n item_size = item / bins\\n scores = (1 / available_capacity) * np.sqrt(1 / bin_number) * np.sqrt(item_size)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin as the sum of the multiplication of the inverse of the available capacity and the bin number, and the subtraction of the available capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 / bins - bins + item \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A variant form of the provided algorithm, where the score is computed as the sum of the inverse of the bin number and the inverse of the bin's remaining capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / np.arange(1, bins.size + 1) + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm will calculate the score of each bin based on a product of the inverse of the available capacity, the square of the inverse of the bin number, and the square of the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity\\n inv_cap = 1.0 / (bins - item)\\n\\n # Calculate the square of the inverse of the bin number\\n inv_bin_num_sq = np.square(1.0 / np.arange(1, len(bins) + 1))\\n\\n # Calculate the square of the normalized item size\\n norm_item_size_sq = np.square(item / bins)\\n\\n # Calculate the scores\\n scores = inv_cap * inv_bin_num_sq * norm_item_size_sq\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as a product of a normalized inverse of the difference between the bin capacity and the item size, and a normalized index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): A numpy array of rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the normalized inverse of the difference between the bin capacity and the item size.\\n inv_diff = 1.0 / np.maximum(bins - item, 1)\\n\\n # Calculate the normalized index of the bin.\\n idx = np.arange(len(bins)) / len(bins)\\n\\n # Calculate the score for each bin as a product of the normalized inverse of the difference and the normalized index.\\n scores = inv_diff * idx\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\\n\\n Args:\\n item (int): The size of current item.\\n bins (np.ndarray): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Inverse of the available capacity\\n inv_cap = 1 / (bins - item)\\n\\n # Bin number\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Normalized item size\\n norm_item = item / bins\\n\\n # Calculate the scores\\n scores = inv_cap + bin_num + norm_item\\n\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Adds the square of the difference between the item size and the available capacity to the previous algorithm's formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, k=0):\\n scores = (3 - 2 * (bins - item).clip(0, 1) - (bins < item)) / 2 # new algorithm\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, but it penalizes the score of bins with a rest capacity less than the item size. The penalized modification is calculated as (bins - item) / (1 + np.arange(len(bins))) * (1 - min(bins / item, 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins))) * (1 - np.minimum(bins / item, 1))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the sum of the inverse of the remaining capacity and the logarithm of the bin number, weighted by the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n capacity_ratio = bins / item\\n bin_num = np.arange(len(bins)) + 1\\n\\n scores = capacity_ratio / bin_num + np.log(bin_num)\\n scores[capacity_ratio == 0] = 0\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n rest_capacity = max_capacity - bins\\n bin_number = np.arange(len(rest_capacity)) + 1\\n scores = 0.8 * rest_capacity / max_capacity + 0.2 / bin_number\\n scores[rest_capacity < item] = -1\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the product of the inverse of the available capacity, the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n bins_suit = bins[bins >= item]\\n if len(bins_suit) <= 0:\\n return np.zeros(len(bins))\\n item_normalized = item / np.max(bins_suit)\\n scores = 1 / bins_suit * bins_suit + item_normalized\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the reciprocal of the difference between the bin capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the score as a normalized linear function of the bin index plus the rest capacity divided by the normalized bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Normalize the bin indices and the remaining capacities.\\n normalized_bin_indices = (bins - item) / bins\\n normalized_remaining_capacities = bins / (bins - item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_bin_indices * normalized_remaining_capacities\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigning an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square of the inverse of the bin number, and a constant \\\"k\\\". Scores are multiplied by k if the bin's remaining capacity is less than the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / bins\\n\\n # Compute the square of the inverse of the bin number.\\n inv_bin_num_sq = 1.0 / np.arange(1, len(bins) + 1) ** 2\\n\\n # Compute the score for each bin.\\n scores = inv_cap + inv_bin_num_sq + np.log(bins/(bins-item))\\n\\n # Multiply the score by a constant if the bin's remaining capacity is less than the item's size.\\n scores[bins < item] *= 100\\n\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the score for each bin as the inverse of the product of the bin's index and the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Compute the product of the bin's index and the difference between the bin capacity and the item size\\n products = np.multiply(np.arange(1, len(bins) + 1), bins - item)\\n # Compute the inverse of the products\\n scores = 1 / products\\n # Mask out scores for bins with insufficient capacity\\n scores[bins < item] = np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights for the rest capacity and the inverse of the index.\\n weights = np.where(diff >= 0, 1 / diff, 0)\\n\\n # Compute the score for each bin.\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Use the inverse of available capacity, the square root of the inverse of the bin number, and the square root of normalized item size, all multiplied together to score bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n item_size = item / bins\\n scores = (1 / available_capacity) * np.sqrt(1 / bin_number) * np.sqrt(item_size)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score for a bin is computed as the product of the inverse of the rest capacity, the inverse of the bin number, and an indicator function that checks if the remaining capacity is less than half the bin's capacity multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for a bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n indicator = np.where(rest_capacity < item * 0.5, 1, 0)\\n scores = 1 / rest_capacity * 1 / bin_number * indicator\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin as the sum of the multiplication of the inverse of the available capacity and the bin number, and the subtraction of the available capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 / bins - bins + item \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A variant form of the provided algorithm, where the score is computed as the sum of the inverse of the bin number and the inverse of the bin's remaining capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / np.arange(1, bins.size + 1) + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm will calculate the score of each bin based on a product of the inverse of the available capacity, the square of the inverse of the bin number, and the square of the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity\\n inv_cap = 1.0 / (bins - item)\\n\\n # Calculate the square of the inverse of the bin number\\n inv_bin_num_sq = np.square(1.0 / np.arange(1, len(bins) + 1))\\n\\n # Calculate the square of the normalized item size\\n norm_item_size_sq = np.square(item / bins)\\n\\n # Calculate the scores\\n scores = inv_cap * inv_bin_num_sq * norm_item_size_sq\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as a product of a normalized inverse of the difference between the bin capacity and the item size, and a normalized index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): A numpy array of rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the normalized inverse of the difference between the bin capacity and the item size.\\n inv_diff = 1.0 / np.maximum(bins - item, 1)\\n\\n # Calculate the normalized index of the bin.\\n idx = np.arange(len(bins)) / len(bins)\\n\\n # Calculate the score for each bin as a product of the normalized inverse of the difference and the normalized index.\\n scores = inv_diff * idx\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\\n\\n Args:\\n item (int): The size of current item.\\n bins (np.ndarray): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Inverse of the available capacity\\n inv_cap = 1 / (bins - item)\\n\\n # Bin number\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Normalized item size\\n norm_item = item / bins\\n\\n # Calculate the scores\\n scores = inv_cap + bin_num + norm_item\\n\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Adds the square of the difference between the item size and the available capacity to the previous algorithm's formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, k=0):\\n scores = (3 - 2 * (bins - item).clip(0, 1) - (bins < item)) / 2 # new algorithm\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, but it penalizes the score of bins with a rest capacity less than the item size. The penalized modification is calculated as (bins - item) / (1 + np.arange(len(bins))) * (1 - min(bins / item, 1))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins))) * (1 - np.minimum(bins / item, 1))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the reciprocal of the difference between the bin capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the score as a normalized linear function of the bin index plus the rest capacity divided by the normalized bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Normalize the bin indices and the remaining capacities.\\n normalized_bin_indices = (bins - item) / bins\\n normalized_remaining_capacities = bins / (bins - item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_bin_indices * normalized_remaining_capacities\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigning an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square of the inverse of the bin number, and a constant \\\"k\\\". Scores are multiplied by k if the bin's remaining capacity is less than the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / bins\\n\\n # Compute the square of the inverse of the bin number.\\n inv_bin_num_sq = 1.0 / np.arange(1, len(bins) + 1) ** 2\\n\\n # Compute the score for each bin.\\n scores = inv_cap + inv_bin_num_sq + np.log(bins/(bins-item))\\n\\n # Multiply the score by a constant if the bin's remaining capacity is less than the item's size.\\n scores[bins < item] *= 100\\n\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the score for each bin as the inverse of the product of the bin's index and the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Compute the product of the bin's index and the difference between the bin capacity and the item size\\n products = np.multiply(np.arange(1, len(bins) + 1), bins - item)\\n # Compute the inverse of the products\\n scores = 1 / products\\n # Mask out scores for bins with insufficient capacity\\n scores[bins < item] = np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights for the rest capacity and the inverse of the index.\\n weights = np.where(diff >= 0, 1 / diff, 0)\\n\\n # Compute the score for each bin.\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Use the inverse of available capacity, the square root of the inverse of the bin number, and the square root of normalized item size, all multiplied together to score bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n item_size = item / bins\\n scores = (1 / available_capacity) * np.sqrt(1 / bin_number) * np.sqrt(item_size)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score for a bin is computed as the product of the inverse of the rest capacity, the inverse of the bin number, and an indicator function that checks if the remaining capacity is less than half the bin's capacity multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for a bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n indicator = np.where(rest_capacity < item * 0.5, 1, 0)\\n scores = 1 / rest_capacity * 1 / bin_number * indicator\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin as the sum of the multiplication of the inverse of the available capacity and the bin number, and the subtraction of the available capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 / bins - bins + item \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as a weighted sum of the inverse of the available capacity, the bin number, and the normalized item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin as a weighted sum of the inverse of the available capacity, the bin number, and the normalized item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the available capacity.\\n inv_cap = 1.0 / np.maximum(bins - item, 1e-6)\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the normalized item size.\\n norm_item = item / np.max(bins)\\n\\n # Calculate the weights.\\n weights = np.array([0.5, 0.3, 0.2])\\n\\n # Calculate the scores.\\n scores = weights[0] * inv_cap + weights[1] * bin_num + weights[2] * norm_item\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A variant form of the provided algorithm, where the score is computed as the sum of the inverse of the bin number and the inverse of the bin's remaining capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / np.arange(1, bins.size + 1) + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm will calculate the score of each bin based on a product of the inverse of the available capacity, the square of the inverse of the bin number, and the square of the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the available capacity\\n inv_cap = 1.0 / (bins - item)\\n\\n # Calculate the square of the inverse of the bin number\\n inv_bin_num_sq = np.square(1.0 / np.arange(1, len(bins) + 1))\\n\\n # Calculate the square of the normalized item size\\n norm_item_size_sq = np.square(item / bins)\\n\\n # Calculate the scores\\n scores = inv_cap * inv_bin_num_sq * norm_item_size_sq\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as a product of a normalized inverse of the difference between the bin capacity and the item size, and a normalized index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): A numpy array of rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the normalized inverse of the difference between the bin capacity and the item size.\\n inv_diff = 1.0 / np.maximum(bins - item, 1)\\n\\n # Calculate the normalized index of the bin.\\n idx = np.arange(len(bins)) / len(bins)\\n\\n # Calculate the score for each bin as a product of the normalized inverse of the difference and the normalized index.\\n scores = inv_diff * idx\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Modified algorithm: Calculate the score for each bin as the sum of the inverse of the available capacity, the bin number, and the normalized item size.\\n\\n Args:\\n item (int): The size of current item.\\n bins (np.ndarray): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Inverse of the available capacity\\n inv_cap = 1 / (bins - item)\\n\\n # Bin number\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Normalized item size\\n norm_item = item / bins\\n\\n # Calculate the scores\\n scores = inv_cap + bin_num + norm_item\\n\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Adds the square of the difference between the item size and the available capacity to the previous algorithm's formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, k=0):\\n scores = (3 - 2 * (bins - item).clip(0, 1) - (bins < item)) / 2 # new algorithm\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have smaller differences between their capacity and the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\\n scores[bins - item <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the score as a normalized linear function of the bin index plus the rest capacity divided by the normalized bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Normalize the bin indices and the remaining capacities.\\n normalized_bin_indices = (bins - item) / bins\\n normalized_remaining_capacities = bins / (bins - item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_bin_indices * normalized_remaining_capacities\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigning an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square of the inverse of the bin number, and a constant \\\"k\\\". Scores are multiplied by k if the bin's remaining capacity is less than the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / bins\\n\\n # Compute the square of the inverse of the bin number.\\n inv_bin_num_sq = 1.0 / np.arange(1, len(bins) + 1) ** 2\\n\\n # Compute the score for each bin.\\n scores = inv_cap + inv_bin_num_sq + np.log(bins/(bins-item))\\n\\n # Multiply the score by a constant if the bin's remaining capacity is less than the item's size.\\n scores[bins < item] *= 100\\n\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the score for each bin as the inverse of the product of the bin's index and the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Compute the product of the bin's index and the difference between the bin capacity and the item size\\n products = np.multiply(np.arange(1, len(bins) + 1), bins - item)\\n # Compute the inverse of the products\\n scores = 1 / products\\n # Mask out scores for bins with insufficient capacity\\n scores[bins < item] = np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights for the rest capacity and the inverse of the index.\\n weights = np.where(diff >= 0, 1 / diff, 0)\\n\\n # Compute the score for each bin.\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute the score for each bin as the weighted sum of the bin's rest capacity and the reciprocal of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Compute the score for each bin as the weighted sum of the bin's rest capacity and the reciprocal of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights as the reciprocal of the difference.\\n weights = 1 / diff\\n\\n # Compute the scores as the weighted sum of the bin's rest capacity and the reciprocal of its index.\\n scores = weights * bins + 1 / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores a bin as the sum of the multiplication of the inverse of the bin number, the inverse of the bin's remaining capacity, and an indicator function that checks if the remaining capacity is less than half the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n \\n remaining_capacities = bins - item\\n \\n inverse_bin_numbers = 1 / np.array(range(1, len(bins) + 1))\\n \\n inverse_remaining_capacities = 1 / remaining_capacities\\n \\n half_capacities = bins / 2\\n \\n low_capacity_indicator = np.where(remaining_capacities < half_capacities, 1, 0)\\n \\n scores = inverse_bin_numbers * inverse_remaining_capacities * low_capacity_indicator\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Use the inverse of available capacity, the square root of the inverse of the bin number, and the square root of normalized item size, all multiplied together to score bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n item_size = item / bins\\n scores = (1 / available_capacity) * np.sqrt(1 / bin_number) * np.sqrt(item_size)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score for a bin is computed as the product of the inverse of the rest capacity, the inverse of the bin number, and an indicator function that checks if the remaining capacity is less than half the bin's capacity multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for a bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n indicator = np.where(rest_capacity < item * 0.5, 1, 0)\\n scores = 1 / rest_capacity * 1 / bin_number * indicator\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin as the sum of the square root of the inverse of the bin number and the square root of the inverse of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores each bin as the sum of the square root of the inverse of the bin number and the square root of the inverse of the bin's remaining capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n bin_nums = np.arange(len(bins)) + 1\\n bin_capacities = bins - item\\n scores = np.sqrt(1 / bin_nums) + np.sqrt(1 / bin_capacities)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin as the sum of the multiplication of the inverse of the available capacity and the bin number, and the subtraction of the available capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 / bins - bins + item \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square root of the inverse of the bin number, and a constant \\\"k\\\".\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / (bins - item)\\n\\n # Compute the square root of the inverse of the bin number.\\n inv_bin = 1.0 / np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Compute the scores.\\n scores = inv_cap + inv_bin + 0.5\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as a weighted sum of the inverse of the available capacity, the bin number, and the normalized item size, where the weights are learned from data.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin as a weighted sum of the inverse of the available capacity, the bin number, and the normalized item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the available capacity.\\n inv_cap = 1.0 / np.maximum(bins - item, 1e-6)\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the normalized item size.\\n norm_item = item / np.max(bins)\\n\\n # Calculate the weights.\\n weights = np.array([0.5, 0.3, 0.2])\\n\\n # Calculate the scores.\\n scores = weights[0] * inv_cap + weights[1] * bin_num + weights[2] * norm_item\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A variant form of the provided algorithm, where the score is computed as the sum of the inverse of the bin number and the inverse of the bin's remaining capacity.\",\n \"code\": \"def score(item, bins):\\n scores = 1 / np.arange(1, bins.size + 1) + 1 / (bins - item)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at most three times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n # Penalize bins with remaining capacity less than half of the item size\\n scores[bins - item <= 0.5 * item] -= 0.5\\n # Mask out invalid bins (remaining capacity less than the item size)\\n scores[bins - item < 0] = -np.inf\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have smaller differences between their capacity and the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\\n scores[bins - item <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the score as a normalized linear function of the bin index plus the rest capacity divided by the normalized bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Normalize the bin indices and the remaining capacities.\\n normalized_bin_indices = (bins - item) / bins\\n normalized_remaining_capacities = bins / (bins - item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_bin_indices * normalized_remaining_capacities\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities within 20% of the item size, penalized if the remaining capacity is less than 10% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\",\n \"code\": \"def score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Prioritize bins that have capacities within 20% of the item size, penalized if the remaining capacity is less than 10% of the item size:\\n scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\\n \\\"\\\"\\\"\\n assert np.all(bins >= item), \\\"Bins must have sufficient capacity to accommodate the item\\\"\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigning an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square of the inverse of the bin number, and a constant \\\"k\\\". Scores are multiplied by k if the bin's remaining capacity is less than the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / bins\\n\\n # Compute the square of the inverse of the bin number.\\n inv_bin_num_sq = 1.0 / np.arange(1, len(bins) + 1) ** 2\\n\\n # Compute the score for each bin.\\n scores = inv_cap + inv_bin_num_sq + np.log(bins/(bins-item))\\n\\n # Multiply the score by a constant if the bin's remaining capacity is less than the item's size.\\n scores[bins < item] *= 100\\n\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the score for each bin as the inverse of the product of the bin's index and the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Compute the product of the bin's index and the difference between the bin capacity and the item size\\n products = np.multiply(np.arange(1, len(bins) + 1), bins - item)\\n # Compute the inverse of the products\\n scores = 1 / products\\n # Mask out scores for bins with insufficient capacity\\n scores[bins < item] = np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights for the rest capacity and the inverse of the index.\\n weights = np.where(diff >= 0, 1 / diff, 0)\\n\\n # Compute the score for each bin.\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute the score for each bin as the weighted sum of the bin's rest capacity and the reciprocal of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Compute the score for each bin as the weighted sum of the bin's rest capacity and the reciprocal of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights as the reciprocal of the difference.\\n weights = 1 / diff\\n\\n # Compute the scores as the weighted sum of the bin's rest capacity and the reciprocal of its index.\\n scores = weights * bins + 1 / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores a bin as the sum of the multiplication of the inverse of the bin number, the inverse of the bin's remaining capacity, and an indicator function that checks if the remaining capacity is less than half the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n \\n remaining_capacities = bins - item\\n \\n inverse_bin_numbers = 1 / np.array(range(1, len(bins) + 1))\\n \\n inverse_remaining_capacities = 1 / remaining_capacities\\n \\n half_capacities = bins / 2\\n \\n low_capacity_indicator = np.where(remaining_capacities < half_capacities, 1, 0)\\n \\n scores = inverse_bin_numbers * inverse_remaining_capacities * low_capacity_indicator\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Use the inverse of available capacity, the square root of the inverse of the bin number, and the square root of normalized item size, all multiplied together to score bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n item_size = item / bins\\n scores = (1 / available_capacity) * np.sqrt(1 / bin_number) * np.sqrt(item_size)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score for a bin is computed as the product of the inverse of the rest capacity, the inverse of the bin number, and an indicator function that checks if the remaining capacity is less than half the bin's capacity multiplied by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for a bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacity = bins - item\\n bin_number = np.arange(len(bins)) + 1\\n indicator = np.where(rest_capacity < item * 0.5, 1, 0)\\n scores = 1 / rest_capacity * 1 / bin_number * indicator\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin as the sum of the square root of the inverse of the bin number and the square root of the inverse of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores each bin as the sum of the square root of the inverse of the bin number and the square root of the inverse of the bin's remaining capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n bin_nums = np.arange(len(bins)) + 1\\n bin_capacities = bins - item\\n scores = np.sqrt(1 / bin_nums) + np.sqrt(1 / bin_capacities)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns an item to the bin with the maximum score calculated as the harmonic mean of the remaining capacity and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (2 * bins - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin as the inverse of the difference between the bin capacity and the item size, with a penalty for bins that reach half of the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = 1 / (bins - item)\\n scores[bins <= half_capacity] -= 1\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: the score function will calculate the score of a bin based on an indicator function that checks if the rest capacity is more than twice the item size, and then takes the difference between the bin index and the number of feasible bins.\",\n \"code\": \"def score(item, bins):\\n indicator = np.where(bins > 2 * item, 1, 0)\\n num_feasible = np.count_nonzero(indicator)\\n scores = indicator * (bins - item) - (bins - num_feasible)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins based on the sum of the inverse of the remaining capacity and the inverse of the item size, with a higher penalty for bins with smaller remaining capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1.0 / (bins - item) + 1.0 / item - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the sum of the inverse of the remaining capacity and the item size, with a higher penalty for bins with smaller remaining capacity: scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item < 0.5 * item)\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Prioritize bins that have capacities 2 times the item size, penalized if the remaining capacity is less than half of the item size:\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n \\\"\\\"\\\"\\n scores = 1.0 / (bins - item) * (bins <= 2 * item) - 0.2 * (bins - item <= 0.5 * item)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for a bin is computed as the product of the inverse of the square root of the rest capacity and the inverse of the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for a bin.\\n\\n The score is computed as the product of the inverse of the square root of the\\n rest capacity and the inverse of the square root of the bin number.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n rest_capacities = np.maximum(bins - item, 0)\\n bin_numbers = np.arange(len(bins)) + 1\\n scores = rest_capacities / np.sqrt(rest_capacities) * 1 / np.sqrt(bin_numbers)\\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities at most three times the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = 1.0 / (bins - item) * (bins <= 3 * item) - 0.2 * (bins - item <= 0.5 * item)\\n # Penalize bins with remaining capacity less than half of the item size\\n scores[bins - item <= 0.5 * item] -= 0.5\\n # Mask out invalid bins (remaining capacity less than the item size)\\n scores[bins - item < 0] = -np.inf\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have smaller differences between their capacity and the item size, penalized if the remaining capacity is less than half of the item size: scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) - 0.2 * (bins - item <= 0.5 * item)\\n scores[bins - item <= 0] = -np.inf\\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm computes a score for each bin based on the reciprocal of the difference between the bin capacity and the item size, and a penalty for bins with smaller remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n scores = 1.0 / np.maximum((bins - item), 1e-12) - 0.1 * (bins - item < 0.5 * item)\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score for each bin as the weighted sum of the bin's rest capacity and the inverse of its remaining percentage capacity, with the weights determined by the square of the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Compute the score for each bin to assign an item.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n if len(bins) == 0:\\n return np.array([0])\\n\\n max_capacity = np.max(bins)\\n if max_capacity == item:\\n return np.zeros_like(bins)\\n\\n weights = np.square(bins - max_capacity)\\n rest_capacity = bins - item\\n remaining_percentage_capacity = rest_capacity / max_capacity\\n scores = weights * rest_capacity + 1 / remaining_percentage_capacity\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 30% of the item size, penalized if the remaining capacity is less than 10% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.3 * item) - 0.1 * (bins - item <= 0.1 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.3 * item) - 0.1 * (bins - item <= 0.1 * item)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins that have capacities within 15% of the item size, penalized if the remaining capacity is less than 5% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.15 * item) - 0.05 * (bins - item <= 0.05 * item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Prioritize bins that have capacities within 15% of the item size, penalized if the remaining capacity is less than 5% of the item size.\\n \\n Args:\\n item: Size of the current item to be assigned. (int)\\n bins: Rest capacities of feasible bins, which are larger than the item size. (np.ndarray)\\n \\n Returns:\\n Scores for the bins for assignment. (np.ndarray)\\n \\\"\\\"\\\"\\n\\n # Penalize bins with less than 5% remaining capacity\\n penalty = np.where(bins - item <= 0.05 * item, -0.05, 0.0)\\n\\n # Calculate scores\\n scores = 1.0 / (bins - item) * np.where(np.abs(bins - item) <= 0.15 * item, 1.0, 0.0) + penalty\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the score as a normalized linear function of the bin index plus the rest capacity divided by the normalized bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Normalize the bin indices and the remaining capacities.\\n normalized_bin_indices = (bins - item) / bins\\n normalized_remaining_capacities = bins / (bins - item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_bin_indices * normalized_remaining_capacities\\n\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins that have capacities within 20% of the item size, penalized if the remaining capacity is less than 10% of the item size: scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\",\n \"code\": \"def score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Prioritize bins that have capacities within 20% of the item size, penalized if the remaining capacity is less than 10% of the item size:\\n scores = 1.0 / (bins - item) * (abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\\n \\\"\\\"\\\"\\n assert np.all(bins >= item), \\\"Bins must have sufficient capacity to accommodate the item\\\"\\n scores = 1.0 / (bins - item) * (np.abs(bins - item) <= 0.2 * item) - 0.1 * (bins - item <= 0.1 * item)\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is computed as the exponential of the sum of the bin's index and the difference between the bin capacity and the item size multiplied by the difference between the bin's index and the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin, given an item and a list of bins.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diffs = bins - item\\n\\n # Calculate the difference between the bin's index and the number of bins.\\n idx_diffs = np.arange(len(bins)) - len(bins)\\n\\n # Compute the exponential of the sum of the bin's index and the difference between the bin capacity and the item size.\\n scores = np.exp(idx_diffs * diffs)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigning an item to the bin with the maximum score, computed as the sum of the inverse of the remaining capacity, the square of the inverse of the bin number, and a constant \\\"k\\\". Scores are multiplied by k if the bin's remaining capacity is less than the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the remaining capacity.\\n inv_cap = 1.0 / bins\\n\\n # Compute the square of the inverse of the bin number.\\n inv_bin_num_sq = 1.0 / np.arange(1, len(bins) + 1) ** 2\\n\\n # Compute the score for each bin.\\n scores = inv_cap + inv_bin_num_sq + np.log(bins/(bins-item))\\n\\n # Multiply the score by a constant if the bin's remaining capacity is less than the item's size.\\n scores[bins < item] *= 100\\n\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Compute the score for each bin as the inverse of the product of the bin's index and the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Compute the product of the bin's index and the difference between the bin capacity and the item size\\n products = np.multiply(np.arange(1, len(bins) + 1), bins - item)\\n # Compute the inverse of the products\\n scores = 1 / products\\n # Mask out scores for bins with insufficient capacity\\n scores[bins < item] = np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm with a different parameter setting: score = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1), where weights = np.where(diff >= 0, 1 / diff, 0)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.where(bins >= item, 1 / (bins - item), 0)\\n scores = weights * bins + (1 - weights) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Compute the score for each bin as the weighted sum of the bin's rest capacity and the reciprocal of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Compute the score for each bin as the weighted sum of the bin's rest capacity and the reciprocal of its index, with the weights determined by the difference between the bin's and item's maximum capacities.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the difference between the bin's and item's maximum capacities.\\n diff = bins - item\\n\\n # Compute the weights as the reciprocal of the difference.\\n weights = 1 / diff\\n\\n # Compute the scores as the weighted sum of the bin's rest capacity and the reciprocal of its index.\\n scores = weights * bins + 1 / np.arange(1, len(bins) + 1)\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores a bin as the sum of the multiplication of the inverse of the bin number, the inverse of the bin's remaining capacity, and an indicator function that checks if the remaining capacity is less than half the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n \\n remaining_capacities = bins - item\\n \\n inverse_bin_numbers = 1 / np.array(range(1, len(bins) + 1))\\n \\n inverse_remaining_capacities = 1 / remaining_capacities\\n \\n half_capacities = bins / 2\\n \\n low_capacity_indicator = np.where(remaining_capacities < half_capacities, 1, 0)\\n \\n scores = inverse_bin_numbers * inverse_remaining_capacities * low_capacity_indicator\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the reciprocal of the remaining capacity for each bin, with a penalty for bins at maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.maximum(bins - item, 0) - np.maximum(bins - item, 0) / np.maximum(bins, 1)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the minimum rest capacity, avoiding bins with rest capacity equal to the item size; If multiple bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have a rest capacity equal to the item size.\\n if np.any(bins == item):\\n return np.zeros_like(bins)\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin. Avoid bins with rest capacity equal to the item size.\\n scores = rest_capacities/bins\\n scores[rest_capacities == 0] = -np.inf\\n \\n # If any bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\\n max_capacity = np.max(bins[rest_capacities == np.min(rest_capacities)])\\n scores[bins == max_capacity] = np.inf\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the maximum between the available capacity and the item size, and set the score to -1 if the rest capacity equals the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.min((bins - item, np.zeros_like(bins)), axis=0)\\n scores[bins == bins.max()] = -1\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the average rest capacities of the bins whose rest capacities are smaller than the item size and subtracts minimum rest capacity from all of them to calculate the final score, then assigns the item to the bin with the maximum score.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculates the scores for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for assigning the item to each bin.\\n \\\"\\\"\\\"\\n # Find the bins with sufficient capacity.\\n feasible_bins = bins[bins >= item]\\n\\n # Calculate the average remaining capacity of the feasible bins.\\n avg_capacity = np.mean(feasible_bins)\\n\\n # Subtract the minimum remaining capacity from all feasible bins.\\n scores = feasible_bins - np.min(feasible_bins)\\n\\n # Calculate the final score for each bin.\\n scores = scores + (avg_capacity - scores) * (feasible_bins < avg_capacity)\\n\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score for each bin based on the ratio of the item size to the remaining capacity, with a bias towards larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function takes two inputs:\\n \\n 1. item: The size of the current item to be assigned.\\n 2. bins: A Numpy array containing the remaining capacities of feasible bins, which are larger than the item size.\\n\\n It returns a Numpy array named 'scores', where each element represents the score for assigning the item to the corresponding bin. The goal is to minimize the number of used bins.\\n\\n The scoring function is based on the ratio of the item size to the remaining capacity, with a bias towards larger capacities.\\n \\\"\\\"\\\"\\n\\n # Calculate the score for each bin as the ratio of the item size to the remaining capacity\\n scores = item / bins\\n\\n # Add a bias towards larger capacities by multiplying the score by the remaining capacity\\n scores *= bins\\n\\n # Return the scores\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate bin scores as the product of normalized capacity and the inverse square root of the bin number, then scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculate bin scores as the product of normalized capacity and the inverse square root of the bin number, then scale scores relative to the maximum value.\\n\\n Args:\\n item (int): Size of current item\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n inverse_sqrt_bin_numbers = 1 / np.sqrt(np.arange(1, len(bins) + 1))\\n scores = normalized_capacities * inverse_sqrt_bin_numbers\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score for each bin based on the ratio of the item size to the remaining capacity, with a bias towards smaller capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) ** 2\\n # Penalize bins that are almost full\\n scores[bins <= item] = 0\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate scores as rest capacity divided by maximum capacity, penalizing bins at maximum capacity and assigning the item to the bin with the highest score, reducing the need for new bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates scores for bins to assign an item.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate scores as rest capacity divided by maximum capacity.\\n scores = bins / np.max(bins)\\n\\n # Penalize bins at maximum capacity.\\n scores[bins == np.max(bins)] = 0\\n\\n # Reduce the need for new bins.\\n scores = scores - (bins - item) / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.05232,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the ratio between item size and remaining capacity in each bin, penalize maximum capacity bins and normalize the scores by dividing by the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n :param item: the size of the current item\\n :type item: int\\n :param bins: the rest capacities of the feasible bins\\n :type bins: numpy.ndarray\\n :return: the scores for the bins for assignment\\n :rtype: numpy.ndarray\\n \\\"\\\"\\\"\\n\\n # Compute the ratio between item size and remaining capacity in each bin\\n ratios = item / bins\\n\\n # Penalize bins that are at maximum capacity\\n penalties = np.where(bins == item, 1, 0)\\n\\n # Normalize the scores by dividing by the number of bins\\n scores = ratios / penalties / len(bins)\\n\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the scores for each bin based on the rest capacity,\\n prioritizing bins with higher rest capacity and lower index.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after adding the item.\\n rest_capacities = bins - item\\n\\n scores = rest_capacities / bins\\n # incrementally penalize bins with larger index\\n scores = scores - np.arange(len(bins)) / 10\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.06208,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The score function will assign a score to each bin based on its remaining capacity and a penalty for maximum capacity bins, and then prioritize bins with higher remaining capacity and lower indices for item assignment. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins for assignment.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Remaining capacities of feasible bins.\\n\\n Returns:\\n Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bin has remaining capacity equal to the item size. If so,\\n # return a score of -1 for that bin. This will prevent it from being used.\\n max_bin_capacity = np.max(bins)\\n if max_bin_capacity == item:\\n scores = -np.ones_like(bins)\\n else:\\n # Calculate the remaining capacity of each bin as a percentage of the\\n # maximum capacity.\\n remaining_capacity = bins / max_bin_capacity\\n\\n # Calculate the penalty for bins with maximum capacity.\\n penalty = (bins <= 0)\\n\\n # Calculate the score for each bin.\\n scores = remaining_capacity - penalty\\n\\n # Prioritize bins with higher remaining capacity and lower indices.\\n scores = scores / bins\\n\\n return scores\",\n \"objective\": 0.08794,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2 * (1-((bins - item) > 1 * item)) * (-1e6) \",\n \"code\": \"import numpy as np\\nnp.seterr(invalid='ignore')\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 1 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number, penalized if the rest capacity is less than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the difference between the bin rest capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\\n scores = 1 / (max_capacity * diff * bin_num)\\n\\n # Penalize if the rest capacity is less than twice the item size.\\n scores[diff < 2 * item] -= 1\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the inverse of the ratio of the item size to the maximum capacity, divided by the product of the square root of the bin's number and the ratio of the item size to the maximum capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Calculate the ratio of the item size to the bin's remaining capacity\\n ratio1 = item / (bins - item)\\n\\n # Calculate the inverse of the ratio of the item size to the maximum capacity\\n ratio2 = 1 / (item / bins)\\n\\n # Calculate the square root of the bin's number\\n sqrt_bin_num = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio of the item size to the maximum capacity\\n ratio3 = item / bins\\n\\n # Calculate the score of each bin\\n scores = (ratio1 + ratio2) / (sqrt_bin_num * ratio3)\\n\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^3 * (1-((bins - item) > 3 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**3 * (1-((bins - item) > 3 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Bin score increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Novel score function for assigning an item to a bin.\\n\\n The score function increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\\n\\n :param item: Size of the current item.\\n :param bins: Rest capacities of feasible bins, which are larger than the item size.\\n :return: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n scores = item / np.sqrt(np.maximum(bins - item, 0)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by the reciprocal of the product of its index and the difference between its rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate scores for a set of bins.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin rest capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the product of the bin index and the difference.\\n scores = 1 / (np.arange(len(bins)) + 1) / diff\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins * (bins - item) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity plus the bin number divided by the maximum capacity, penalizing bins with smaller rest capacity and larger size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item) + bins / bins.max())\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1e6 divided by the remaining capacity, penalizing bins with a capacity less than half the item size.\",\n \"code\": \"def score(item, bins):\\n scores = 1e6 / (bins - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to penalize bins with large remaining capacities and/or small item sizes. The new algorithm scores each bin as the ratio of its remaining capacity to the sum of its index and the item size, exponentially penalized by the difference between the remaining capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n remaining_capacities = bins - item\\n index_arr = np.arange(len(bins))\\n scores = np.exp(-np.abs(remaining_capacities)) / (remaining_capacities + index_arr + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n max_capacity = np.max(bins)\\n scores = (item / bins + np.sqrt(np.arange(len(bins)) + 1)) - (item / max_capacity)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates each bin's score as the sum of the square root of item size divided by the bin's capacity, square root of the bin's number, and square root of 1 divided by the bin's number, subtracting the bin's capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) + np.sqrt(np.arange(1, len(bins) + 1)) + np.sqrt(1 / np.arange(1, len(bins) + 1)) - bins / np.max(bins)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the square root of the bin's number, divided by the ratio of the item size to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the square root of the bin's number, divided by the ratio of the item size to the maximum capacity.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the ratio of the item size to the bin's remaining capacity.\\n ratios = item / bins\\n\\n # Calculate the square root of the bin's number.\\n sqrt_bins = np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = ratios + sqrt_bins / (item / np.max(bins))\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2 * (1-((bins - item) > 1 * item)) * (-1e6) \",\n \"code\": \"import numpy as np\\nnp.seterr(invalid='ignore')\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 1 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: 1/(square root(bins - item)) + (5000 * (1-((bins - item) > item))) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.sqrt(bins - item)) + (5000 * (1 - ((bins - item) > item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.5 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.ndarray): A Numpy array of integer values representing the remaining capacities of feasible bins.\\n\\n Returns:\\n scores (np.ndarray): A Numpy array of scores for each bin.\\n \\\"\\\"\\\"\\n \\n scores = (bins - item) ** 2 * (1 - ((bins - item) > 0.5 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number, penalized if the rest capacity is less than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the difference between the bin rest capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\\n scores = 1 / (max_capacity * diff * bin_num)\\n\\n # Penalize if the rest capacity is less than twice the item size.\\n scores[diff < 2 * item] -= 1\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the inverse of the ratio of the item size to the maximum capacity, divided by the product of the square root of the bin's number and the ratio of the item size to the maximum capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Calculate the ratio of the item size to the bin's remaining capacity\\n ratio1 = item / (bins - item)\\n\\n # Calculate the inverse of the ratio of the item size to the maximum capacity\\n ratio2 = 1 / (item / bins)\\n\\n # Calculate the square root of the bin's number\\n sqrt_bin_num = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio of the item size to the maximum capacity\\n ratio3 = item / bins\\n\\n # Calculate the score of each bin\\n scores = (ratio1 + ratio2) / (sqrt_bin_num * ratio3)\\n\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^3 * (1-((bins - item) > 3 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**3 * (1-((bins - item) > 3 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Bin score increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Novel score function for assigning an item to a bin.\\n\\n The score function increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\\n\\n :param item: Size of the current item.\\n :param bins: Rest capacities of feasible bins, which are larger than the item size.\\n :return: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n scores = item / np.sqrt(np.maximum(bins - item, 0)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: (bins - item)^2 * exp(-(bins - item)/(item * 0.8)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * np.exp(-(bins - item)/(item * 0.8)) * (-1e6)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins * (bins - item) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity plus the bin number divided by the maximum capacity, penalizing bins with smaller rest capacity and larger size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item) + bins / bins.max())\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1e6 divided by the remaining capacity, penalizing bins with a capacity less than half the item size.\",\n \"code\": \"def score(item, bins):\\n scores = 1e6 / (bins - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to penalize bins with large remaining capacities and/or small item sizes. The new algorithm scores each bin as the ratio of its remaining capacity to the sum of its index and the item size, exponentially penalized by the difference between the remaining capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n remaining_capacities = bins - item\\n index_arr = np.arange(len(bins))\\n scores = np.exp(-np.abs(remaining_capacities)) / (remaining_capacities + index_arr + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n max_capacity = np.max(bins)\\n scores = (item / bins + np.sqrt(np.arange(len(bins)) + 1)) - (item / max_capacity)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2 * (1-((bins - item) > 1 * item)) * (-1e6) \",\n \"code\": \"import numpy as np\\nnp.seterr(invalid='ignore')\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 1 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: 1/(square root(bins - item)) + (5000 * (1-((bins - item) > item))) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.sqrt(bins - item)) + (5000 * (1 - ((bins - item) > item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.5 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Compute the score for each bin for assigning an item.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.ndarray): A Numpy array of integer values representing the remaining capacities of feasible bins.\\n\\n Returns:\\n scores (np.ndarray): A Numpy array of scores for each bin.\\n \\\"\\\"\\\"\\n \\n scores = (bins - item) ** 2 * (1 - ((bins - item) > 0.5 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number, penalized if the rest capacity is less than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the difference between the bin rest capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\\n scores = 1 / (max_capacity * diff * bin_num)\\n\\n # Penalize if the rest capacity is less than twice the item size.\\n scores[diff < 2 * item] -= 1\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the inverse of the ratio of the item size to the maximum capacity, divided by the product of the square root of the bin's number and the ratio of the item size to the maximum capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Calculate the ratio of the item size to the bin's remaining capacity\\n ratio1 = item / (bins - item)\\n\\n # Calculate the inverse of the ratio of the item size to the maximum capacity\\n ratio2 = 1 / (item / bins)\\n\\n # Calculate the square root of the bin's number\\n sqrt_bin_num = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio of the item size to the maximum capacity\\n ratio3 = item / bins\\n\\n # Calculate the score of each bin\\n scores = (ratio1 + ratio2) / (sqrt_bin_num * ratio3)\\n\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^3 * (1-((bins - item) > 3 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**3 * (1-((bins - item) > 3 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Bin score increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Novel score function for assigning an item to a bin.\\n\\n The score function increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\\n\\n :param item: Size of the current item.\\n :param bins: Rest capacities of feasible bins, which are larger than the item size.\\n :return: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n scores = item / np.sqrt(np.maximum(bins - item, 0)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: (bins - item)^2 * exp(-(bins - item)/(item * 0.8)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * np.exp(-(bins - item)/(item * 0.8)) * (-1e6)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins * (bins - item) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity plus the bin number divided by the maximum capacity, penalizing bins with smaller rest capacity and larger size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item) + bins / bins.max())\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1e6 divided by the remaining capacity, penalizing bins with a capacity less than half the item size.\",\n \"code\": \"def score(item, bins):\\n scores = 1e6 / (bins - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to penalize bins with large remaining capacities and/or small item sizes. The new algorithm scores each bin as the ratio of its remaining capacity to the sum of its index and the item size, exponentially penalized by the difference between the remaining capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n remaining_capacities = bins - item\\n index_arr = np.arange(len(bins))\\n scores = np.exp(-np.abs(remaining_capacities)) / (remaining_capacities + index_arr + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2 * (1-((bins - item) > 1 * item)) * (-1e6) \",\n \"code\": \"import numpy as np\\nnp.seterr(invalid='ignore')\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 1 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\\n\\n Args:\\n item (int): size of current item\\n bins (np.ndarray): rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1. / np.power((bins - item) / item, 1 / (bins - item)) * (bins - item)\\n scores *= (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^2 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (((bins - item) / item)**2) * (bins-item) * (1 - (bins > (2*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item) ** 2 * (1 - ((bins - item) > threshold * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) > item * 0.9)) * (-1e6)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: 1/(square root(bins - item)) + (5000 * (1-((bins - item) > item))) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.sqrt(bins - item)) + (5000 * (1 - ((bins - item) > item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2.5 * (1-((bins - item) > 0.5 * item)) * (-1e6) \",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2.5 * (1 - ((bins - item) > 0.5 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number, penalized if the rest capacity is less than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the difference between the bin rest capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\\n scores = 1 / (max_capacity * diff * bin_num)\\n\\n # Penalize if the rest capacity is less than twice the item size.\\n scores[diff < 2 * item] -= 1\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)**2.5 * (1-((bins - item) > 2.5 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n # Calculate the difference between the bin capacity and item size\\n diff = bins - item\\n\\n # Calculate the score using the formula\\n scores = (diff**2.5) * (1 - (diff > 2.5 * item)) * (-1e6)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the inverse of the ratio of the item size to the maximum capacity, divided by the product of the square root of the bin's number and the ratio of the item size to the maximum capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Calculate the ratio of the item size to the bin's remaining capacity\\n ratio1 = item / (bins - item)\\n\\n # Calculate the inverse of the ratio of the item size to the maximum capacity\\n ratio2 = 1 / (item / bins)\\n\\n # Calculate the square root of the bin's number\\n sqrt_bin_num = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio of the item size to the maximum capacity\\n ratio3 = item / bins\\n\\n # Calculate the score of each bin\\n scores = (ratio1 + ratio2) / (sqrt_bin_num * ratio3)\\n\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^3 * (1-((bins - item) > 3 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**3 * (1-((bins - item) > 3 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score is the ratio of item size to the rest capacity minus the bin number, penalizing bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Bin score increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Novel score function for assigning an item to a bin.\\n\\n The score function increases with the ratio of item size to the square root of rest capacity plus the bin number, penalizing bins with smaller rest capacity more heavily.\\n\\n :param item: Size of the current item.\\n :param bins: Rest capacities of feasible bins, which are larger than the item size.\\n :return: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n scores = item / np.sqrt(np.maximum(bins - item, 0)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: (bins - item)^2 * exp(-(bins - item)/(item * 0.8)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * np.exp(-(bins - item)/(item * 0.8)) * (-1e6)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign score as (bins - item)**(item/bins) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(item/bins) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin in 'bins' for the item of size 'item'.\\n The score is computed as follows:\\n score = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6))\\n The bin with the maximum score is selected for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2 * item)) * (-1e6))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score as the product of the difference between the bin rest capacity and the item size, the ratio of the item size to the bin rest capacity, and a penalty if the rest capacity is less than the sum of the item size and a margin value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculates the score for each bin in bins for assigning an item of size item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of scores for each bin in bins.\\n \\\"\\\"\\\"\\n # Calculate the difference between the bin rest capacity and the item size\\n diff = bins - item\\n\\n # Calculate the ratio of the item size to the bin rest capacity\\n ratio = item / bins\\n\\n # Calculate a penalty if the rest capacity is less than the sum of the item size and a margin value\\n penalty = np.where(diff < item, diff - item, 0)\\n\\n # Calculate the score as the product of the difference, ratio, and penalty\\n scores = diff * ratio * penalty\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\\n\\n Args:\\n item (int): size of current item\\n bins (np.ndarray): rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1. / np.power((bins - item) / item, 1 / (bins - item)) * (bins - item)\\n scores *= (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^2 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (((bins - item) / item)**2) * (bins-item) * (1 - (bins > (2*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: Modified Algorithm: (bins - item)^4 * (1-((bins - item) > 0.85 * item)) * (-1e6)\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n A novel score function that scoring a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Check if the item can fit in any bin.\\n if np.all(bins < item):\\n return np.zeros_like(bins)\\n\\n # Calculate the scores for each bin.\\n scores = (bins - item) ** 4 * (1 - ((bins - item) > 0.85 * item)) * (-1e6)\\n\\n # Set the score of any bin that cannot fit the item to -inf.\\n scores[bins < item] = -np.inf\\n\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item) ** 2 * (1 - ((bins - item) > threshold * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) > item * 0.9)) * (-1e6)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: (bins - item)^2 * (1-((bins - item) > 0.75 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1 - (bins - item > 0.75*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^6 * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n I need help designing a novel score function that scoring a set of bins to assign an item. In each step, the item will be assigned to the bin with the maximum score. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\\n I have existing algorithm idea as follows: \\n New algorithm: (bins - item)^6 * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n Please implement it in Python as a function named score. This function should accept 2 input(s): 'item', 'bins'. The function should return 1 output(s): 'scores'. 'item' and 'bins' are the size of current item and the rest capacities of feasible bins, which are larger than the item size. The output named 'scores' is the scores for the bins for assignment. Note that 'item' is of type int, 'bins' is a Numpy array include integer values, and 'scores' should be Numpy array. The function should be complicated enough to promote performance. Avoid utilizing the random component, and it is crucial to maintain self-consistency.\\n Do not give any additional explanations!\\n \\\"\\\"\\\"\\n delta = bins - item\\n scores = np.power(delta, 6) * (1 - (delta > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2.5 * (1-((bins - item) > 0.5 * item)) * (-1e6) \",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2.5 * (1 - ((bins - item) > 0.5 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number, penalized if the rest capacity is less than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the difference between the bin rest capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\\n scores = 1 / (max_capacity * diff * bin_num)\\n\\n # Penalize if the rest capacity is less than twice the item size.\\n scores[diff < 2 * item] -= 1\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)**2.5 * (1-((bins - item) > 2.5 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n # Calculate the difference between the bin capacity and item size\\n diff = bins - item\\n\\n # Calculate the score using the formula\\n scores = (diff**2.5) * (1 - (diff > 2.5 * item)) * (-1e6)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins-item)**(2+rand()) * (1-((bins-item) > (2+rand()) * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item to.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger\\n than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.power(diff, 2 + np.random.rand()) * (1 - (diff > (2 + np.random.rand()) * item)) * (-1e6)\\n\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the inverse of the ratio of the item size to the maximum capacity, divided by the product of the square root of the bin's number and the ratio of the item size to the maximum capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Calculate the ratio of the item size to the bin's remaining capacity\\n ratio1 = item / (bins - item)\\n\\n # Calculate the inverse of the ratio of the item size to the maximum capacity\\n ratio2 = 1 / (item / bins)\\n\\n # Calculate the square root of the bin's number\\n sqrt_bin_num = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio of the item size to the maximum capacity\\n ratio3 = item / bins\\n\\n # Calculate the score of each bin\\n scores = (ratio1 + ratio2) / (sqrt_bin_num * ratio3)\\n\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign score as (bins - item)**(item/bins) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(item/bins) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin in 'bins' for the item of size 'item'.\\n The score is computed as follows:\\n score = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6))\\n The bin with the maximum score is selected for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2 * item)) * (-1e6))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score as the product of the difference between the bin rest capacity and the item size, the ratio of the item size to the bin rest capacity, and a penalty if the rest capacity is less than the sum of the item size and a margin value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculates the score for each bin in bins for assigning an item of size item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of scores for each bin in bins.\\n \\\"\\\"\\\"\\n # Calculate the difference between the bin rest capacity and the item size\\n diff = bins - item\\n\\n # Calculate the ratio of the item size to the bin rest capacity\\n ratio = item / bins\\n\\n # Calculate a penalty if the rest capacity is less than the sum of the item size and a margin value\\n penalty = np.where(diff < item, diff - item, 0)\\n\\n # Calculate the score as the product of the difference, ratio, and penalty\\n scores = diff * ratio * penalty\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * (-1e6)\\n\\n Args:\\n item (int): size of current item\\n bins (np.ndarray): rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = 1. / np.power((bins - item) / item, 1 / (bins - item)) * (bins - item)\\n scores *= (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * log(bins) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for assigning an item to a bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the remaining capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have enough capacity to hold the item.\\n feasible_bins = bins[bins >= item]\\n if len(feasible_bins) == 0:\\n return np.array([0])\\n\\n # Calculate the scores for the feasible bins.\\n scores = 1 / ((bins - item) / item)**(1 / (bins - item)) * (bins - item) * (1 - (bins > 2 * item)) * np.log(bins) * (-1e6)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^2 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (((bins - item) / item)**2) * (bins-item) * (1 - (bins > (2*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Modified Algorithm: (bins - item)^3 * (1-((bins - item) > 0.85 * item)) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculate the score for each bin in bins for assigning an item of size item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of integers representing the remaining capacities of feasible bins, \\n which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin using the given formula.\\n scores = np.power(diff, 3) * (1 - (diff > 0.85 * item)) * (-1e5)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item) ** 2 * (1 - ((bins - item) > threshold * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) > item * 0.9)) * (-1e6)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: (bins - item)^2 * (1-((bins - item) > 0.75 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1 - (bins - item > 0.75*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)**2 * (1-((bins - item) > 0.9 * item)) * (-10**6) \",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.9 * item)) * (-10**6)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^6 * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n I need help designing a novel score function that scoring a set of bins to assign an item. In each step, the item will be assigned to the bin with the maximum score. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\\n I have existing algorithm idea as follows: \\n New algorithm: (bins - item)^6 * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n Please implement it in Python as a function named score. This function should accept 2 input(s): 'item', 'bins'. The function should return 1 output(s): 'scores'. 'item' and 'bins' are the size of current item and the rest capacities of feasible bins, which are larger than the item size. The output named 'scores' is the scores for the bins for assignment. Note that 'item' is of type int, 'bins' is a Numpy array include integer values, and 'scores' should be Numpy array. The function should be complicated enough to promote performance. Avoid utilizing the random component, and it is crucial to maintain self-consistency.\\n Do not give any additional explanations!\\n \\\"\\\"\\\"\\n delta = bins - item\\n scores = np.power(delta, 6) * (1 - (delta > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**1.5 * (1-((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Modified algorithm: (bins - item)^2 * (1-((bins - item) > 0.6 * item)) * (-1e6) \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function takes an item size and a list of bin capacities and returns a score for each bin.\\n\\n The score is calculated as follows:\\n (bins - item)^2 * (1-((bins - item) > 0.6 * item)) * (-1e6)\\n\\n If the remaining capacity of a bin is equal to the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A list of the remaining capacities of the feasible bins.\\n\\n Returns:\\n A numpy array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n scores = (bins - item)**2 * (1-np.where(bins - item > 0.6 * item, 1, 0)) * (-1e6)\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2.5 * (1-((bins - item) > 0.5 * item)) * (-1e6) \",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2.5 * (1 - ((bins - item) > 0.5 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number, penalized if the rest capacity is less than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the difference between the bin rest capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\\n scores = 1 / (max_capacity * diff * bin_num)\\n\\n # Penalize if the rest capacity is less than twice the item size.\\n scores[diff < 2 * item] -= 1\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)**2 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin in 'bins' for the item of size 'item'.\\n The score is computed as follows:\\n score = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6))\\n The bin with the maximum score is selected for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2 * item)) * (-1e6))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score as the product of the difference between the bin rest capacity and the item size, the ratio of the item size to the bin rest capacity, and a penalty if the rest capacity is less than the sum of the item size and a margin value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculates the score for each bin in bins for assigning an item of size item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of scores for each bin in bins.\\n \\\"\\\"\\\"\\n # Calculate the difference between the bin rest capacity and the item size\\n diff = bins - item\\n\\n # Calculate the ratio of the item size to the bin rest capacity\\n ratio = item / bins\\n\\n # Calculate a penalty if the rest capacity is less than the sum of the item size and a margin value\\n penalty = np.where(diff < item, diff - item, 0)\\n\\n # Calculate the score as the product of the difference, ratio, and penalty\\n scores = diff * ratio * penalty\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns a score as (bins - item) * ((bins - item)/item)^(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins - item)/item)**(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * log(bins + 1) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.maximum((bins - item) / item, 1e-10))**(1 / (bins - item)) * (bins - item) * (1 - (bins > 2 * item)) * np.log(bins + 1) * (-1e5)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^2 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (((bins - item) / item)**2) * (bins-item) * (1 - (bins > (2*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Modified Algorithm: (bins - item)^3 * (1-((bins - item) > 0.85 * item)) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculate the score for each bin in bins for assigning an item of size item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of integers representing the remaining capacities of feasible bins, \\n which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin using the given formula.\\n scores = np.power(diff, 3) * (1 - (diff > 0.85 * item)) * (-1e5)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item) ** 2 * (1 - ((bins - item) > threshold * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) > item * 0.9)) * (-1e6)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: (bins - item)^2 * (1-((bins - item) > 0.75 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1 - (bins - item > 0.75*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)**2 * (1-((bins - item) > 0.9 * item)) * (-10**6) \",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.9 * item)) * (-10**6)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^6 * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n I need help designing a novel score function that scoring a set of bins to assign an item. In each step, the item will be assigned to the bin with the maximum score. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\\n I have existing algorithm idea as follows: \\n New algorithm: (bins - item)^6 * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n Please implement it in Python as a function named score. This function should accept 2 input(s): 'item', 'bins'. The function should return 1 output(s): 'scores'. 'item' and 'bins' are the size of current item and the rest capacities of feasible bins, which are larger than the item size. The output named 'scores' is the scores for the bins for assignment. Note that 'item' is of type int, 'bins' is a Numpy array include integer values, and 'scores' should be Numpy array. The function should be complicated enough to promote performance. Avoid utilizing the random component, and it is crucial to maintain self-consistency.\\n Do not give any additional explanations!\\n \\\"\\\"\\\"\\n delta = bins - item\\n scores = np.power(delta, 6) * (1 - (delta > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: (bins - item)^2 * (1-((bins - item) > 0.7 * item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.7 * item)) * (-1e5)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^3 * (1 - e^(-1*(bins - item)/item)) * (1-((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**3 * (1 - np.exp(-1*(bins - item)/item)) * (1-((bins - item) > 0.6 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)^2.5 * (1-((bins - item) > 0.5 * item)) * (-1e6) \",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2.5 * (1 - ((bins - item) > 0.5 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number, penalized if the rest capacity is less than twice the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the difference between the bin rest capacity and the item size.\\n diff = bins - item\\n\\n # Calculate the bin number.\\n bin_num = np.arange(len(bins)) + 1\\n\\n # Calculate the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\\n scores = 1 / (max_capacity * diff * bin_num)\\n\\n # Penalize if the rest capacity is less than twice the item size.\\n scores[diff < 2 * item] -= 1\\n\\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item)**3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.5/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) * 0.5 / item) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin in 'bins' for the item of size 'item'.\\n The score is computed as follows:\\n score = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6))\\n The bin with the maximum score is selected for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2 * item)) * (-1e6))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score as the product of the difference between the bin rest capacity and the item size, the ratio of the item size to the bin rest capacity, and a penalty if the rest capacity is less than the sum of the item size and a margin value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"\\n Calculates the score for each bin in bins for assigning an item of size item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of scores for each bin in bins.\\n \\\"\\\"\\\"\\n # Calculate the difference between the bin rest capacity and the item size\\n diff = bins - item\\n\\n # Calculate the ratio of the item size to the bin rest capacity\\n ratio = item / bins\\n\\n # Calculate a penalty if the rest capacity is less than the sum of the item size and a margin value\\n penalty = np.where(diff < item, diff - item, 0)\\n\\n # Calculate the score as the product of the difference, ratio, and penalty\\n scores = diff * ratio * penalty\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign a score based on the difference between bin capacity and item size, incorporating various modifiers to account for underutilization penalties and thresholds. My new algorithm assigns a score as (bins - item)**2 * (1 - ((bins - item)/item)^(1/2)) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) / item) ** (1 / 2)) * (1 - (bins >= 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^1 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / item)**1 * (bins - item) * (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1/((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + log(item)/5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + np.log(item)/5)\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns a score as (bins - item) * ((bins - item)/item)^(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins - item)/item)**(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * log(bins + 1) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.maximum((bins - item) / item, 1e-10))**(1 / (bins - item)) * (bins - item) * (1 - (bins > 2 * item)) * np.log(bins + 1) * (-1e5)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^2 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (((bins - item) / item)**2) * (bins-item) * (1 - (bins > (2*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item) * ((bins/item)^3 + 5) * (1-((bins - item) > 0.85 * item)) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins / item) ** 3 + 5) * (1 - ((bins - item) > 0.85 * item)) * (-1e5)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^4 * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**4 * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: ((bins - item) / (bins - item)^2) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins - item) / (bins - item)**2) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: (bins - item)^2 * (1-((bins - item) > 0.75 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1 - (bins - item > 0.75*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: (bins - item)**2 * (1-((bins - item) > 0.9 * item)) * (-10**6) \",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.9 * item)) * (-10**6)\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**4 * (1-((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-1e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the scores for a set of bins to assign an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-1e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item)**3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1-((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes a score for each bin for assigning an item to it.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (numpy.array): The remaining capacities of the feasible bins.\\n\\n Returns:\\n numpy.array: The scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins can hold the item.\\n if np.all(bins < item):\\n return np.zeros(bins.shape)\\n\\n # Compute the scores for the bins.\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n\\n # Mask out the bins that cannot hold the item.\\n scores[bins < item] = -np.inf\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.5/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) * 0.5 / item) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin in 'bins' for the item of size 'item'.\\n The score is computed as follows:\\n score = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6))\\n The bin with the maximum score is selected for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2 * item)) * (-1e6))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\",\n \"code\": \"def score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign a score based on the difference between bin capacity and item size, incorporating various modifiers to account for underutilization penalties and thresholds. My new algorithm assigns a score as (bins - item)**2 * (1 - ((bins - item)/item)^(1/2)) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) / item) ** (1 / 2)) * (1 - (bins >= 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^1 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / item)**1 * (bins - item) * (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1/((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + log(item)/5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + np.log(item)/5)\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns a score as (bins - item) * ((bins - item)/item)^(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins - item)/item)**(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * log(bins + 1) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.maximum((bins - item) / item, 1e-10))**(1 / (bins - item)) * (bins - item) * (1 - (bins > 2 * item)) * np.log(bins + 1) * (-1e5)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score as exp(-(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item) * ((bins/item)^3 + 5) * (1-((bins - item) > 0.85 * item)) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins / item) ** 3 + 5) * (1 - ((bins - item) > 0.85 * item)) * (-1e5)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^4 * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**4 * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: ((bins - item) / (bins - item)^2) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins - item) / (bins - item)**2) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.6/item) * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the remaining capacities of the bins.\\n\\n Returns:\\n A Numpy array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Compute the score for each bin.\\n scores = np.log(bins - item) / (1 + (bins - item) * 0.6 / item) * (1 - ((bins - item) > 0.8 * item)) * (-1e6)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item)**3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1-((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes a score for each bin for assigning an item to it.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (numpy.array): The remaining capacities of the feasible bins.\\n\\n Returns:\\n numpy.array: The scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins can hold the item.\\n if np.all(bins < item):\\n return np.zeros(bins.shape)\\n\\n # Compute the scores for the bins.\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n\\n # Mask out the bins that cannot hold the item.\\n scores[bins < item] = -np.inf\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.5/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) * 0.5 / item) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin in 'bins' for the item of size 'item'.\\n The score is computed as follows:\\n score = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6))\\n The bin with the maximum score is selected for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2 * item)) * (-1e6))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\",\n \"code\": \"def score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign a score based on the difference between bin capacity and item size, incorporating various modifiers to account for underutilization penalties and thresholds. My new algorithm assigns a score as (bins - item)**2 * (1 - ((bins - item)/item)^(1/2)) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) / item) ** (1 / 2)) * (1 - (bins >= 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^1 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / item)**1 * (bins - item) * (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1/((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + log(item)/5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + np.log(item)/5)\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns a score as (bins - item) * ((bins - item)/item)^(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins - item)/item)**(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Assigns score as 1/((bins - item)/item)^(1/(bins-item)) * (bins - item) * (1 - (bins > 2*item)) * log(bins + 1) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (np.maximum((bins - item) / item, 1e-10))**(1 / (bins - item)) * (bins - item) * (1 - (bins > 2 * item)) * np.log(bins + 1) * (-1e5)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score as exp(-(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item) * ((bins/item)^3 + 5) * (1-((bins - item) > 0.85 * item)) * (-1e5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins / item) ** 3 + 5) * (1 - ((bins - item) > 0.85 * item)) * (-1e5)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as ln(bins - item) * (1 - ((bins - item) > 0.9 * item)) * (1 - ((bins - item) < 0.1 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the difference between bins and item\\n dif = bins - item\\n # Calculate the ratio of difference and item\\n ratio = dif / item\\n # Calculate the natural logarithm of bins - item\\n ln_bins_item = np.log(bins - item)\\n # Calculate the score\\n scores = ln_bins_item * (1 - (ratio > 0.9)) * (1 - (ratio < 0.1)) * (-1e6)\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Assign a score based on the ratio of the bin capacity to the difference between the bin capacity and the item size, weighted by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / np.maximum(0, bins - item)) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the sum of the rest capacity and the bin number\\n inv_sum_rest_cap_bin_num = 1.0 / (bins + np.arange(1, bins.size + 1))\\n # Calculate the rest capacity divided by the maximum capacity\\n rest_cap_div_max_cap = bins / np.max(bins)\\n # Calculate the score\\n scores = inv_sum_rest_cap_bin_num - rest_cap_div_max_cap\\n # Return the scores\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Calculate bin scores as the product of normalized capacity and the negative exponential of the bin number multiplied by the item size ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for an item. The bin with the highest score should be assigned the item.\\n\\n Args:\\n item: int, size of the item to be assigned\\n bins: Numpy array, rest capacities of feasible bins\\n\\n Returns:\\n scores: Numpy array, scores for the bins\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n exponential_weights = np.exp(-bins * item / np.max(bins))\\n scores = normalized_capacities * exponential_weights\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the minimum rest capacity, avoiding bins with rest capacity equal to the item size; If multiple bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have a rest capacity equal to the item size.\\n if np.any(bins == item):\\n return np.zeros_like(bins)\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin. Avoid bins with rest capacity equal to the item size.\\n scores = rest_capacities/bins\\n scores[rest_capacities == 0] = -np.inf\\n \\n # If any bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\\n max_capacity = np.max(bins[rest_capacities == np.min(rest_capacities)])\\n scores[bins == max_capacity] = np.inf\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin scores as the product of normalized capacity and the exponential decay of bin number, then scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates bin scores for item assignment.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Numpy array of remaining capacities of feasible bins.\\n\\n Returns:\\n Numpy array of bin scores.\\n \\\"\\\"\\\"\\n\\n # Calculate normalized capacities.\\n capacities = bins / np.max(bins)\\n\\n # Calculate exponential decay of bin numbers.\\n decay = np.exp(-np.arange(len(bins)))\\n\\n # Calculate bin scores.\\n scores = capacities * decay\\n\\n # Scale scores relative to the maximum value.\\n scores /= np.max(scores)\\n\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate the score for each bin as the maximum between the available capacity and the item size, and set the score to -1 if the rest capacity equals the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.min((bins - item, np.zeros_like(bins)), axis=0)\\n scores[bins == bins.max()] = -1\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the average rest capacities of the bins whose rest capacities are smaller than the item size and subtracts minimum rest capacity from all of them to calculate the final score, then assigns the item to the bin with the maximum score.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculates the scores for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for assigning the item to each bin.\\n \\\"\\\"\\\"\\n # Find the bins with sufficient capacity.\\n feasible_bins = bins[bins >= item]\\n\\n # Calculate the average remaining capacity of the feasible bins.\\n avg_capacity = np.mean(feasible_bins)\\n\\n # Subtract the minimum remaining capacity from all feasible bins.\\n scores = feasible_bins - np.min(feasible_bins)\\n\\n # Calculate the final score for each bin.\\n scores = scores + (avg_capacity - scores) * (feasible_bins < avg_capacity)\\n\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin scores as the sum of normalized capacity and the inverse of the bin number, scaled by the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for item assignment.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Normalize bin capacities\\n max_capacity = np.max(bins)\\n normalized_bins = bins / max_capacity\\n\\n # Calculate bin scores\\n scores = normalized_bins + 1 / np.arange(1, len(bins) + 1)\\n\\n # Scale scores by maximum score\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score for each bin based on the ratio of the item size to the remaining capacity, with a bias towards larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function takes two inputs:\\n \\n 1. item: The size of the current item to be assigned.\\n 2. bins: A Numpy array containing the remaining capacities of feasible bins, which are larger than the item size.\\n\\n It returns a Numpy array named 'scores', where each element represents the score for assigning the item to the corresponding bin. The goal is to minimize the number of used bins.\\n\\n The scoring function is based on the ratio of the item size to the remaining capacity, with a bias towards larger capacities.\\n \\\"\\\"\\\"\\n\\n # Calculate the score for each bin as the ratio of the item size to the remaining capacity\\n scores = item / bins\\n\\n # Add a bias towards larger capacities by multiplying the score by the remaining capacity\\n scores *= bins\\n\\n # Return the scores\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate bin scores as the product of normalized capacity and the inverse square root of the bin number, then scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculate bin scores as the product of normalized capacity and the inverse square root of the bin number, then scale scores relative to the maximum value.\\n\\n Args:\\n item (int): Size of current item\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n inverse_sqrt_bin_numbers = 1 / np.sqrt(np.arange(1, len(bins) + 1))\\n scores = normalized_capacities * inverse_sqrt_bin_numbers\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin that has the smallest rest capacity after adding the item size and penalize any bin with rest capacity equal to maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = np.zeros_like(bins)\\n free_bins = bins >= item # Mark feasible bins\\n scores[free_bins] = - bins[free_bins] # Prioritize bins with less space left\\n scores[bins == item] -= bins[bins == item] # Extra penalty for overfilled bins\\n scores[bins == bins.max()] = -bins.max() # Prevent using full bins\\n return scores\",\n \"objective\": 0.0486,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin scores as the product of normalized capacity and the exponential decay of bin number, then weight the scores by inverse of the square root of capacity and scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin scores for item assignment.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.ndarray): Rest capacities of feasible bins.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate normalized capacity\\n normalized_capacities = bins / np.amax(bins)\\n\\n # Calculate exponential decay of bin number\\n bin_numbers = np.arange(len(bins))\\n exponential_decay = np.exp(-bin_numbers / 10)\\n\\n # Calculate bin scores\\n scores = normalized_capacities * exponential_decay\\n\\n # Weight scores by inverse of square root of capacity\\n scores = scores / np.sqrt(bins)\\n\\n # Scale scores relative to maximum value\\n scores = scores / np.amax(scores)\\n\\n # Return scores\\n return scores\",\n \"objective\": 0.049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign a score for each bin based on the ratio of the item size to the remaining capacity, with a bias towards larger capacities. Item size is also considered in a score equation\",\n \"code\": \"def score(item, bins):\\n scores = bins / (bins - item)\\n scores[bins - item <= 0] = -float('inf')\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate scores as rest capacity divided by maximum capacity, penalizing bins at maximum capacity and assigning the item to the bin with the highest score, reducing the need for new bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates scores for bins to assign an item.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate scores as rest capacity divided by maximum capacity.\\n scores = bins / np.max(bins)\\n\\n # Penalize bins at maximum capacity.\\n scores[bins == np.max(bins)] = 0\\n\\n # Reduce the need for new bins.\\n scores = scores - (bins - item) / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.05232,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Compute the ratio between item size and remaining capacity in each bin, penalize maximum capacity bins and normalize the scores by dividing by the number of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n :param item: the size of the current item\\n :type item: int\\n :param bins: the rest capacities of the feasible bins\\n :type bins: numpy.ndarray\\n :return: the scores for the bins for assignment\\n :rtype: numpy.ndarray\\n \\\"\\\"\\\"\\n\\n # Compute the ratio between item size and remaining capacity in each bin\\n ratios = item / bins\\n\\n # Penalize bins that are at maximum capacity\\n penalties = np.where(bins == item, 1, 0)\\n\\n # Normalize the scores by dividing by the number of bins\\n scores = ratios / penalties / len(bins)\\n\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin scores as the product of reversed normalized capacity and the square root of the bin number, then scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the bin scores for assigning an item to a bin.\\n \\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the remaining capacities of the feasible bins, \\n which are larger than the item size.\\n\\n Returns:\\n scores: A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the reversed normalized capacities.\\n cap = 1 - bins / bins.max()\\n\\n # Calculate the square root of the bin numbers.\\n bin_num = np.arange(len(bins)) + 1\\n root = np.sqrt(bin_num)\\n\\n # Calculate the bin scores.\\n scores = cap * root\\n\\n # Scale the scores relative to the maximum value.\\n scores /= scores.max()\\n\\n return scores\",\n \"objective\": 0.05433,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.6/item) * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the remaining capacities of the bins.\\n\\n Returns:\\n A Numpy array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Compute the score for each bin.\\n scores = np.log(bins - item) / (1 + (bins - item) * 0.6 / item) * (1 - ((bins - item) > 0.8 * item)) * (-1e6)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1 + (bins - item)/item) * (1 - ((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Assigns an item to a bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): Size of the current item.\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins_capacity = bins - item\\n scores = np.log(bins_capacity) * (1 + bins_capacity/item) * (1 - (bins_capacity > 0.6 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.4/item) * (1-((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n availability_factor = np.log((bins - item) / (1 + (bins - item) * 0.4 / item))\\n overflow_factor = 1 - ((bins - item) > 0.6 * item)\\n scores = availability_factor * overflow_factor * (-1e6)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item)**3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.5/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) * 0.5 / item) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (1 - ((bins - item) >= 0.90 * item)) * (-1e6)\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (1 - ((bins - item) >= 0.90 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as log(bins - item)/(1 - (bins - item)/item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) / (1 - (bins - item) / item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin in 'bins' for the item of size 'item'.\\n The score is computed as follows:\\n score = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e6))\\n The bin with the maximum score is selected for assignment. If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins >= 2 * item)) * (-1e6))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\",\n \"code\": \"def score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign a score based on the difference between bin capacity and item size, incorporating various modifiers to account for underutilization penalties and thresholds. My new algorithm assigns a score as (bins - item)**2 * (1 - ((bins - item)/item)^(1/2)) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) / item) ** (1 / 2)) * (1 - (bins >= 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^1 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / item)**1 * (bins - item) * (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e9)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e9)}\\n \\n Args:\\n item: The size of current item.\\n bins: A Numpy array include integer values, representing the rest capacities of feasible bins, which are larger than the item size.\\n \\n Returns:\\n scores: The scores for the bins for assignment. This should be a Numpy array.\\n \\\"\\\"\\\"\\n\\n # Compute the scores for each bin.\\n delta = bins - item\\n term1 = np.power(delta, 1 / (delta / item))\\n term2 = 1 - (bins >= 2 * item)\\n term3 = np.power(-1e9, term2)\\n scores = np.multiply(np.multiply(term1, term2), term3)\\n\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1/((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + log(item)/5)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item)/item) * (bins - item) * (1 - (bins > 2 * item)) * (-1e9) * (1 + np.log(item)/5)\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns a score as (bins - item) * ((bins - item)/item)^(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * ((bins - item)/item)**(1/(bins - item)) * (1 - (bins >=2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to give high scores to bins with sufficient remaining capacity and penalize bins that are nearly full. My new algorithm: log(bins - item) / log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / np.log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.6/item) * (1-((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the remaining capacities of the bins.\\n\\n Returns:\\n A Numpy array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Compute the score for each bin.\\n scores = np.log(bins - item) / (1 + (bins - item) * 0.6 / item) * (1 - ((bins - item) > 0.8 * item)) * (-1e6)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1 + (bins - item)/item) * (1 - ((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Assigns an item to a bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): Size of the current item.\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins_capacity = bins - item\\n scores = np.log(bins_capacity) * (1 + bins_capacity/item) * (1 - (bins_capacity > 0.6 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.4/item) * (1-((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n availability_factor = np.log((bins - item) / (1 + (bins - item) * 0.4 / item))\\n overflow_factor = 1 - ((bins - item) > 0.6 * item)\\n scores = availability_factor * overflow_factor * (-1e6)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item)**3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"\\n Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n\\n Args:\\n item (int): Size of current item\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.array: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/log(bins) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) / np.log(bins) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (1 - ((bins - item) >= 0.90 * item)) * (-1e6)\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (1 - ((bins - item) >= 0.90 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as log(bins - item)/(1 - (bins - item)/item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) / (1 - (bins - item) / item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e8)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e8)}\\n\\n Args:\\n item: size of current item\\n bins: rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n scores: the scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = np.power(bins - item, 1 / ((bins - item) / item) * (1 - (bins >= 2 * item)) * (-1e8))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\",\n \"code\": \"def score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign a score based on the difference between bin capacity and item size, incorporating various modifiers to account for underutilization penalties and thresholds. My new algorithm assigns a score as (bins - item)**2 * (1 - ((bins - item)/item)^(1/2)) * (1 - (bins >= 2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 2 * (1 - ((bins - item) / item) ** (1 / 2)) * (1 - (bins >= 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as 1/((bins - item)/item)^1 * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / ((bins - item) / item)**1 * (bins - item) * (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to give high scores to bins with sufficient remaining capacity and penalize bins that are nearly full. My new algorithm: log(bins - item) / log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / np.log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score as log(max(bins - item, 0)) * 1 / (1 + log(min(bins - item, bins / 2))) * (1 - ((bins - item) > 0.8*item)) * (1 - ((bins - item) > 1.8*item)) * (1 - (bins >= 2.2*item)) * (-1e9)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(np.clip(bins - item, 0, None)) * 1 / (1 + np.log(np.clip(bins - item, 0, bins / 2))) * (1 - ((bins - item) > 0.8 * item)) * (1 - ((bins - item) > 1.8 * item)) * (1 - (bins >= 2.2 * item)) * (-1e9)\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1 + (bins - item)/item) * (1 - ((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Assigns an item to a bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): Size of the current item.\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins_capacity = bins - item\\n scores = np.log(bins_capacity) * (1 + bins_capacity/item) * (1 - (bins_capacity > 0.6 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.4/item) * (1-((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n availability_factor = np.log((bins - item) / (1 + (bins - item) * 0.4 / item))\\n overflow_factor = 1 - ((bins - item) > 0.6 * item)\\n scores = availability_factor * overflow_factor * (-1e6)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item)**3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item) ** 3 * (-1e6) * (1 - ((bins - item) > 0.5 * bins))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"\\n Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n\\n Args:\\n item (int): Size of current item\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.array: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/log(bins) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) / np.log(bins) * (1 - ((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (1 - ((bins - item) >= 0.90 * item)) * (-1e6)\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (1 - ((bins - item) >= 0.90 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as log(bins - item)/(1 - (bins - item)/item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) / (1 - (bins - item) / item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e8)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e8)}\\n\\n Args:\\n item: size of current item\\n bins: rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n scores: the scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = np.power(bins - item, 1 / ((bins - item) / item) * (1 - (bins >= 2 * item)) * (-1e8))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-2e6))\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-2e6)\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to give high scores to bins with sufficient remaining capacity and penalize bins that are nearly full. My new algorithm: log(bins - item) / log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / np.log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score as log(max(bins - item, 0)) * 1 / (1 + log(min(bins - item, bins / 2))) * (1 - ((bins - item) > 0.8*item)) * (1 - ((bins - item) > 1.8*item)) * (1 - (bins >= 2.2*item)) * (-1e9)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(np.clip(bins - item, 0, None)) * 1 / (1 + np.log(np.clip(bins - item, 0, bins / 2))) * (1 - ((bins - item) > 0.8 * item)) * (1 - ((bins - item) > 1.8 * item)) * (1 - (bins >= 2.2 * item)) * (-1e9)\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1 + (bins - item)/item) * (1 - ((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Assigns an item to a bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): Size of the current item.\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins_capacity = bins - item\\n scores = np.log(bins_capacity) * (1 + bins_capacity/item) * (1 - (bins_capacity > 0.6 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.4/item) * (1-((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n availability_factor = np.log((bins - item) / (1 + (bins - item) * 0.4 / item))\\n overflow_factor = 1 - ((bins - item) > 0.6 * item)\\n scores = availability_factor * overflow_factor * (-1e6)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm: (bins - item)**2 * (-1e6) * (1 - ((bins - item) / bins > 0.5)) \",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (-1e6) * (1 - ((bins - item) / bins > 0.5))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"\\n Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n\\n Args:\\n item (int): Size of current item\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.array: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns score as (bins - item)^(1/((bins - item)/item) * (1 - (bins > 2*item)) * (1 - (bins > 2.5*item)) * (-1e7)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item)) * (1 - (bins > 2*item)) * (1 - (bins > 2.5*item)) * (-1e7)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as log(bins - item)/(1 - (bins - item)/item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) / (1 - (bins - item) / item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e8)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins >= 2*item)) * (-1e8)}\\n\\n Args:\\n item: size of current item\\n bins: rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n scores: the scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = np.power(bins - item, 1 / ((bins - item) / item) * (1 - (bins >= 2 * item)) * (-1e8))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-2e6))\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-2e6)\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to give high scores to bins with sufficient remaining capacity and penalize bins that are nearly full. My new algorithm: log(bins - item) / log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / np.log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) / log(item) * (1 - ((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\nfrom numba import njit\\n\\n@njit\\ndef score(item: int, bins: np.ndarray):\\n scores = np.log(bins - item) / np.log(item) * (\\n 1 - ((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1 + (bins - item)/item) * (1 - ((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Assigns an item to a bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): Size of the current item.\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins_capacity = bins - item\\n scores = np.log(bins_capacity) * (1 + bins_capacity/item) * (1 - (bins_capacity > 0.6 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.4/item) * (1-((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n availability_factor = np.log((bins - item) / (1 + (bins - item) * 0.4 / item))\\n overflow_factor = 1 - ((bins - item) > 0.6 * item)\\n scores = availability_factor * overflow_factor * (-1e6)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm: (bins - item)**2 * (-1e6) * (1 - ((bins - item) / bins > 0.5)) \",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (-1e6) * (1 - ((bins - item) / bins > 0.5))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"\\n Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n\\n Args:\\n item (int): Size of current item\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.array: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)/item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / (1 + (bins - item) / item) * (1-((bins - item) > 0.9 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns score as (bins - item)^(1/((bins - item)/item) * (1 - (bins > 2*item)) * (1 - (bins > 2.5*item)) * (-1e7)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item)) * (1 - (bins > 2*item)) * (1 - (bins > 2.5*item)) * (-1e7)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign score as log(bins - item)/(1 - (bins - item)/item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(bins - item) / (1 - (bins - item) / item) * (bins-item) * (1 - (bins>2*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)^{1/(bins - item) * (1 - (bins >= 2*item)) * (-1e8)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(1 / (bins - item) * (1 - (bins >= 2*item)) * (-1e8))\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\",\n \"code\": \"def score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.5 * item)) * (-1e6))\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"New algorithm: (log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) * (1 - ((bins - item) > 0.75 * item)) * (-3e6))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.7*item))) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.7*item))) * (-1e5)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to give high scores to bins with sufficient remaining capacity and penalize bins that are nearly full. My new algorithm: log(bins - item) / log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) / np.log(item) * (1 - ((bins - item) > 0.7 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) / log(item) * (1 - ((bins - item) > 0.8 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\nfrom numba import njit\\n\\n@njit\\ndef score(item: int, bins: np.ndarray):\\n scores = np.log(bins - item) / np.log(item) * (\\n 1 - ((bins - item) > 0.8 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)^{1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7)}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.8*item)) * (1 - (bins > 2.2*item)) * (-1e7))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item) * (1 + (bins - item)/item) * (1 - ((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Assigns an item to a bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item (int): Size of the current item.\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins_capacity = bins - item\\n scores = np.log(bins_capacity) * (1 + bins_capacity/item) * (1 - (bins_capacity > 0.6 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: log(bins - item)/(1 + (bins - item)*0.4/item) * (1-((bins - item) > 0.6 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n availability_factor = np.log((bins - item) / (1 + (bins - item) * 0.4 / item))\\n overflow_factor = 1 - ((bins - item) > 0.6 * item)\\n scores = availability_factor * overflow_factor * (-1e6)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**((1/((bins - item)/item)) * (bins < 1.9*item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Assign a score as log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\",\n \"code\": \"def score(item, bins):\\n scores = np.log(1+(bins-item)**2/(bins**2-item**2)) * (1 - (bins > 2*item)) * (-1e5)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Modified algorithm: (bins - item)**2 * (-1e6) * (1 - ((bins - item) / bins > 0.5)) \",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (-1e6) * (1 - ((bins - item) / bins > 0.5))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign a score as the clip(2 * log(bins - item), 0, 1e7) * (1 - (bins - item) / item) * (1 - (bins - item) / bins) * (1 - (bins > 2 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin in 'bins' for assigning an item of size 'item'.\\n The score is calculated as follows:\\n clip(2 * log(bins - item), 0, 1e7) * (1 - (bins - item) / item) * (1 - (bins - item) / bins) * (1 - (bins > 2 * item)) * (-1e6)\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the remaining capacities of feasible bins.\\n Returns:\\n A Numpy array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n scores = np.clip(2 * np.log(bins - item), 0, 1e7)\\n scores *= (1 - (bins - item) / item)\\n scores *= (1 - (bins - item) / bins)\\n scores *= (1 - (bins > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"\\n Assigns score as (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n\\n Args:\\n item (int): Size of current item\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.array: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n scores = (bins - item)**(1/((bins - item)/item) * (1 - (bins > 1.9*item))) * (-1e6)\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins - item) * (1 - ((bins - item) > 0.95 * item)) * (-1e6) * item / bins\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score as (bins - item) ^ 2 * log (bins - item) * (1 - (bins-item)/item) * (1 - (bins>2*item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins - item)**2 * np.log(bins - item) * (1 - (bins - item) / item) * (1 - (bins > 2*item)) * (-1e6))\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: item * log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6) * item / bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * np.log(bins - item) * (1 - ((bins - item) > 0.90 * item)) * (-1e6) * item / bins\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assigns score as (bins - item)^(1/((bins - item)/item) * (1 - (bins > 2*item)) * (1 - (bins > 2.5*item)) * (-1e7)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**(1/((bins - item)/item)) * (1 - (bins > 2*item)) * (1 - (bins > 2.5*item)) * (-1e7)\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Divide the remaining capacity of each bin by the item size to calculate a penalty, and add the penalty to the score of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.ceil(bins / item)\\n scores = bins - penalty * item\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: The new algorithm divides item size by bin's rest capacity, multiplies the fraction by a value less than 1, and adds 1 to the product.}\",\n \"code\": \"def score(item, bins):\\n scores = (item / bins) * 0.99 + 1\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the sum of the rest capacity and the bin number\\n inv_sum_rest_cap_bin_num = 1.0 / (bins + np.arange(1, bins.size + 1))\\n # Calculate the rest capacity divided by the maximum capacity\\n rest_cap_div_max_cap = bins / np.max(bins)\\n # Calculate the score\\n scores = inv_sum_rest_cap_bin_num - rest_cap_div_max_cap\\n # Return the scores\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Calculate bin scores as the product of normalized capacity and the negative exponential of the bin number multiplied by the item size ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for an item. The bin with the highest score should be assigned the item.\\n\\n Args:\\n item: int, size of the item to be assigned\\n bins: Numpy array, rest capacities of feasible bins\\n\\n Returns:\\n scores: Numpy array, scores for the bins\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n exponential_weights = np.exp(-bins * item / np.max(bins))\\n scores = normalized_capacities * exponential_weights\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score as the ratio of the item size to the bin capacity minus the bin number, rewarding bins with larger capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins - np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the minimum rest capacity, avoiding bins with rest capacity equal to the item size; If multiple bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have a rest capacity equal to the item size.\\n if np.any(bins == item):\\n return np.zeros_like(bins)\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin. Avoid bins with rest capacity equal to the item size.\\n scores = rest_capacities/bins\\n scores[rest_capacities == 0] = -np.inf\\n \\n # If any bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\\n max_capacity = np.max(bins[rest_capacities == np.min(rest_capacities)])\\n scores[bins == max_capacity] = np.inf\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin scores as the product of normalized capacity and the exponential decay of bin number, then scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates bin scores for item assignment.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Numpy array of remaining capacities of feasible bins.\\n\\n Returns:\\n Numpy array of bin scores.\\n \\\"\\\"\\\"\\n\\n # Calculate normalized capacities.\\n capacities = bins / np.max(bins)\\n\\n # Calculate exponential decay of bin numbers.\\n decay = np.exp(-np.arange(len(bins)))\\n\\n # Calculate bin scores.\\n scores = capacities * decay\\n\\n # Scale scores relative to the maximum value.\\n scores /= np.max(scores)\\n\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm divides the average rest capacity of feasible bins by the item size and subtracts the result from the rest capacity of each feasible bin to calculate the final score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n if len(feasible_bins) == 0:\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Apply a penalty to bins where remaining capacity is greater than 1.5 times the item size, but increase the penalty for bins with remaining capacity greater than 2 times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n # Assign bonus score for full bins\\n full_bins_mask = (bins == item)\\n scores[full_bins_mask] += 1000\\n \\n # Penalize bins with large remaining capacity\\n penalty_mask_1 = (bins > 1.5 * item) & (bins < 2 * item)\\n scores[penalty_mask_1] -= 100\\n \\n penalty_mask_2 = (bins >= 2 * item)\\n scores[penalty_mask_2] -= 200\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score as the normalized capacity of the bin multiplied by the inverse square root of the current bin number, plus an exponentially decaying number related to the capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin.\\n\\n The item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the normalized capacity of each bin.\\n normalized_capacities = bins / np.max(bins)\\n\\n # Calculate the inverse square root of the current bin number.\\n inverse_square_roots = 1 / np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the exponentially decaying number related to the capacity and the item size.\\n decaying_numbers = np.exp(-(bins - item) / item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_capacities * inverse_square_roots * decaying_numbers\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the average rest capacities of the bins whose rest capacities are smaller than the item size and subtracts minimum rest capacity from all of them to calculate the final score, then assigns the item to the bin with the maximum score.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculates the scores for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for assigning the item to each bin.\\n \\\"\\\"\\\"\\n # Find the bins with sufficient capacity.\\n feasible_bins = bins[bins >= item]\\n\\n # Calculate the average remaining capacity of the feasible bins.\\n avg_capacity = np.mean(feasible_bins)\\n\\n # Subtract the minimum remaining capacity from all feasible bins.\\n scores = feasible_bins - np.min(feasible_bins)\\n\\n # Calculate the final score for each bin.\\n scores = scores + (avg_capacity - scores) * (feasible_bins < avg_capacity)\\n\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin scores as the sum of normalized capacity and the inverse of the bin number, scaled by the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for item assignment.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Normalize bin capacities\\n max_capacity = np.max(bins)\\n normalized_bins = bins / max_capacity\\n\\n # Calculate bin scores\\n scores = normalized_bins + 1 / np.arange(1, len(bins) + 1)\\n\\n # Scale scores by maximum score\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The new algorithm multiplies each bin's score by the ratio of the item's weight to the bin's base capacity, ensuring priority is given to bins that can accommodate the item with less wasted capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of integer values representing the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the ratio of the item's weight to each bin's base capacity.\\n ratios = item / bins\\n\\n # Multiply each bin's score by the ratio.\\n scores = bins * ratios\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.04518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculate bin scores as the product of normalized capacity and the inverse square root of the bin number, then scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculate bin scores as the product of normalized capacity and the inverse square root of the bin number, then scale scores relative to the maximum value.\\n\\n Args:\\n item (int): Size of current item\\n bins (np.ndarray): Rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n inverse_sqrt_bin_numbers = 1 / np.sqrt(np.arange(1, len(bins) + 1))\\n scores = normalized_capacities * inverse_sqrt_bin_numbers\\n return scores\",\n \"objective\": 0.04588,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea is to use a combination of the item size, bin capacity, and bin number to calculate a score for each bin. Our new algorithm calculates the score as the sum of the normalized capacity and the normalized exponential decay of the item size multiplied by the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates a score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the remaining capacities of feasible bins.\\n\\n Returns:\\n A Numpy array of scores for the bins.\\n \\\"\\\"\\\"\\n normalized_capacity = bins / np.max(bins)\\n normalized_item_size = item / np.max(bins)\\n bin_numbers = np.arange(len(bins)) + 1\\n normalized_exponential_decay = np.exp(-normalized_item_size * bin_numbers)\\n scores = normalized_capacity + normalized_exponential_decay\\n return scores\",\n \"objective\": 0.04668,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign an item to the bin that has the smallest rest capacity after adding the item size and penalize any bin with rest capacity equal to maximum capacity.\",\n \"code\": \"def score(item, bins):\\n scores = np.zeros_like(bins)\\n free_bins = bins >= item # Mark feasible bins\\n scores[free_bins] = - bins[free_bins] # Prioritize bins with less space left\\n scores[bins == item] -= bins[bins == item] # Extra penalty for overfilled bins\\n scores[bins == bins.max()] = -bins.max() # Prevent using full bins\\n return scores\",\n \"objective\": 0.0486,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin scores as the product of normalized capacity and the exponential decay of bin number, then weight the scores by inverse of the square root of capacity and scale scores relative to the maximum value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin scores for item assignment.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.ndarray): Rest capacities of feasible bins.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate normalized capacity\\n normalized_capacities = bins / np.amax(bins)\\n\\n # Calculate exponential decay of bin number\\n bin_numbers = np.arange(len(bins))\\n exponential_decay = np.exp(-bin_numbers / 10)\\n\\n # Calculate bin scores\\n scores = normalized_capacities * exponential_decay\\n\\n # Weight scores by inverse of square root of capacity\\n scores = scores / np.sqrt(bins)\\n\\n # Scale scores relative to maximum value\\n scores = scores / np.amax(scores)\\n\\n # Return scores\\n return scores\",\n \"objective\": 0.049,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by the reciprocal of the product of its index and the difference between its rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate scores for a set of bins.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin rest capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the product of the bin index and the difference.\\n scores = 1 / (np.arange(len(bins)) + 1) / diff\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Algorithm: This algorithm includes a new parameter, alpha, and uses the score function: score = alpha * (1 / remaining_capacity) + (1 - alpha) * (cube root of bin number). \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n remaining_capacity = bins - item\\n cube_root_bin_number = np.power(np.arange(len(bins)) + 1, 1 / 3)\\n scores = alpha * (1 / remaining_capacity) + (1 - alpha) * cube_root_bin_number\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: The new algorithm divides item size by bin's rest capacity, multiplies the fraction by a value less than 1, and adds 1 to the product.}\",\n \"code\": \"def score(item, bins):\\n scores = (item / bins) * 0.99 + 1\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the sum of the rest capacity and the bin number\\n inv_sum_rest_cap_bin_num = 1.0 / (bins + np.arange(1, bins.size + 1))\\n # Calculate the rest capacity divided by the maximum capacity\\n rest_cap_div_max_cap = bins / np.max(bins)\\n # Calculate the score\\n scores = inv_sum_rest_cap_bin_num - rest_cap_div_max_cap\\n # Return the scores\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Score function: scores = bins - (bins - item)**3\",\n \"code\": \"def score(item, bins):\\n feasible_bins = bins[bins >= item]\\n scores = feasible_bins - (feasible_bins - item)**3\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Calculate bin scores as the product of normalized capacity and the negative exponential of the bin number multiplied by the item size ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for an item. The bin with the highest score should be assigned the item.\\n\\n Args:\\n item: int, size of the item to be assigned\\n bins: Numpy array, rest capacities of feasible bins\\n\\n Returns:\\n scores: Numpy array, scores for the bins\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n exponential_weights = np.exp(-bins * item / np.max(bins))\\n scores = normalized_capacities * exponential_weights\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score as the ratio of the item size to the bin capacity minus the bin number, rewarding bins with larger capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins - np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Increase the penalty factor for bins with remaining capacity greater than item size by a parameter 'k'.\\nCode:\\ndef new_score(item, bins, k):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > k * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-np.maximum(0, (bins - item) > item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the minimum rest capacity, avoiding bins with rest capacity equal to the item size; If multiple bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have a rest capacity equal to the item size.\\n if np.any(bins == item):\\n return np.zeros_like(bins)\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin. Avoid bins with rest capacity equal to the item size.\\n scores = rest_capacities/bins\\n scores[rest_capacities == 0] = -np.inf\\n \\n # If any bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\\n max_capacity = np.max(bins[rest_capacities == np.min(rest_capacities)])\\n scores[bins == max_capacity] = np.inf\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin scores as a linear combination of bins' remaining capacities and their position in the bin list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculate bin scores as a linear combination of bins' remaining capacities and their position in the bin list.\\n\\n Parameters:\\n item: Size of current item.\\n bins: Numpy array include integer values, which are the rest capacities of feasible bins.\\n\\n Returns:\\n Numpy array named 'scores' with the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n pos_scores = np.arange(len(bins)) + 1 # Positional scores\\n\\n # Capacities are divided by the item size to normalize the scores\\n cap_scores = bins / item\\n\\n # Calculate the final scores\\n scores = 0.5 * cap_scores + 0.5 * pos_scores\\n\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin scores as the product of remaining capacity and the exponential decay of bin number, excluding already full bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores as the product of remaining capacity and the exponential decay of bin number, excluding already full bins.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins = bins[bins >= item]\\n num_bins = len(bins)\\n scores = bins * np.exp(-np.arange(num_bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm divides the average rest capacity of feasible bins by the item size and subtracts the result from the rest capacity of each feasible bin to calculate the final score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n if len(feasible_bins) == 0:\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the inverse of the remaining capacity and the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n scores = 1 / feasible_bins + np.sqrt(np.arange(len(feasible_bins)))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score as the normalized capacity of the bin multiplied by the inverse square root of the current bin number, plus an exponentially decaying number related to the capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin.\\n\\n The item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the normalized capacity of each bin.\\n normalized_capacities = bins / np.max(bins)\\n\\n # Calculate the inverse square root of the current bin number.\\n inverse_square_roots = 1 / np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the exponentially decaying number related to the capacity and the item size.\\n decaying_numbers = np.exp(-(bins - item) / item)\\n\\n # Calculate the score for each bin.\\n scores = normalized_capacities * inverse_square_roots * decaying_numbers\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the product of the inverse of the bin number and the ratio of item size to the rest capacity, favoring both bins with larger rest capacity and smaller bin numbers.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes the score for assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the remaining capacities of the feasible bins.\\n\\n Returns:\\n A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Compute the inverse of the bin numbers.\\n inv_bin_nums = 1.0 / np.arange(1, len(bins) + 1)\\n\\n # Compute the ratio of the item size to the remaining capacity of each bin.\\n item_to_rest_capacity_ratios = item / bins\\n\\n # Compute the scores.\\n scores = inv_bin_nums * item_to_rest_capacity_ratios\\n\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm finds the average rest capacities of the bins whose rest capacities are smaller than the item size and subtracts minimum rest capacity from all of them to calculate the final score, then assigns the item to the bin with the maximum score.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculates the scores for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: The remaining capacities of the feasible bins.\\n\\n Returns:\\n The scores for assigning the item to each bin.\\n \\\"\\\"\\\"\\n # Find the bins with sufficient capacity.\\n feasible_bins = bins[bins >= item]\\n\\n # Calculate the average remaining capacity of the feasible bins.\\n avg_capacity = np.mean(feasible_bins)\\n\\n # Subtract the minimum remaining capacity from all feasible bins.\\n scores = feasible_bins - np.min(feasible_bins)\\n\\n # Calculate the final score for each bin.\\n scores = scores + (avg_capacity - scores) * (feasible_bins < avg_capacity)\\n\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by the reciprocal of the product of its index and the difference between its rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate scores for a set of bins.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin rest capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the product of the bin index and the difference.\\n scores = 1 / (np.arange(len(bins)) + 1) / diff\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: The new algorithm divides item size by bin's rest capacity, multiplies the fraction by a value less than 1, and adds 1 to the product.}\",\n \"code\": \"def score(item, bins):\\n scores = (item / bins) * 0.99 + 1\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the sum of the rest capacity and the bin number\\n inv_sum_rest_cap_bin_num = 1.0 / (bins + np.arange(1, bins.size + 1))\\n # Calculate the rest capacity divided by the maximum capacity\\n rest_cap_div_max_cap = bins / np.max(bins)\\n # Calculate the score\\n scores = inv_sum_rest_cap_bin_num - rest_cap_div_max_cap\\n # Return the scores\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n max_capacity = np.max(bins)\\n scores = (item / bins + np.sqrt(np.arange(len(bins)) + 1)) - (item / max_capacity)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm main parameters: bin capacities and item size. New algorithm: Score function: scores = bins - (bins - item)**2\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - (bins - item)**2\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Calculate bin scores as the product of normalized capacity and the negative exponential of the bin number multiplied by the item size ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for an item. The bin with the highest score should be assigned the item.\\n\\n Args:\\n item: int, size of the item to be assigned\\n bins: Numpy array, rest capacities of feasible bins\\n\\n Returns:\\n scores: Numpy array, scores for the bins\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n exponential_weights = np.exp(-bins * item / np.max(bins))\\n scores = normalized_capacities * exponential_weights\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score of a bin based on the exponential of the reciprocal of the sum of the rest capacity and the bin number, divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score of a bin based on the exponential of the reciprocal of the sum of the rest capacity and the bin number, divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n scores = np.exp(- (bins + np.arange(len(bins)) + 1) / (item + max_capacity))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score as the ratio of the item size to the bin capacity minus the bin number, rewarding bins with larger capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins - np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Increase the penalty factor for bins with remaining capacity greater than item size by a parameter 'k'.\\nCode:\\ndef new_score(item, bins, k):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > k * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-np.maximum(0, (bins - item) > item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the minimum rest capacity, avoiding bins with rest capacity equal to the item size; If multiple bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have a rest capacity equal to the item size.\\n if np.any(bins == item):\\n return np.zeros_like(bins)\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin. Avoid bins with rest capacity equal to the item size.\\n scores = rest_capacities/bins\\n scores[rest_capacities == 0] = -np.inf\\n \\n # If any bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\\n max_capacity = np.max(bins[rest_capacities == np.min(rest_capacities)])\\n scores[bins == max_capacity] = np.inf\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the difference between bin capacity and the maximum capacity minus the item size multiplied by the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score as the difference between bin capacity and the maximum capacity minus the item size multiplied by the bin number.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n scores = bins - max_capacity + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin scores as the product of remaining capacity and the exponential decay of bin number, excluding already full bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores as the product of remaining capacity and the exponential decay of bin number, excluding already full bins.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n bins = bins[bins >= item]\\n num_bins = len(bins)\\n scores = bins * np.exp(-np.arange(num_bins))\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm divides the average rest capacity of feasible bins by the item size and subtracts the result from the rest capacity of each feasible bin to calculate the final score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n if len(feasible_bins) == 0:\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the inverse of the remaining capacity and the square root of the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n scores = 1 / feasible_bins + np.sqrt(np.arange(len(feasible_bins)))\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by the reciprocal of the product of its index and the difference between its rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate scores for a set of bins.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin rest capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the product of the bin index and the difference.\\n scores = 1 / (np.arange(len(bins)) + 1) / diff\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: The new algorithm divides item size by bin's rest capacity, multiplies the fraction by a value less than 1, and adds 1 to the product.}\",\n \"code\": \"def score(item, bins):\\n scores = (item / bins) * 0.99 + 1\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the sum of the rest capacity and the bin number\\n inv_sum_rest_cap_bin_num = 1.0 / (bins + np.arange(1, bins.size + 1))\\n # Calculate the rest capacity divided by the maximum capacity\\n rest_cap_div_max_cap = bins / np.max(bins)\\n # Calculate the score\\n scores = inv_sum_rest_cap_bin_num - rest_cap_div_max_cap\\n # Return the scores\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n max_capacity = np.max(bins)\\n scores = (item / bins + np.sqrt(np.arange(len(bins)) + 1)) - (item / max_capacity)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm main parameters: bin capacities and item size. New algorithm: Score function: scores = bins - (bins - item)**2\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - (bins - item)**2\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Calculate bin scores as the product of normalized capacity and the negative exponential of the bin number multiplied by the item size ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for an item. The bin with the highest score should be assigned the item.\\n\\n Args:\\n item: int, size of the item to be assigned\\n bins: Numpy array, rest capacities of feasible bins\\n\\n Returns:\\n scores: Numpy array, scores for the bins\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n exponential_weights = np.exp(-bins * item / np.max(bins))\\n scores = normalized_capacities * exponential_weights\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns the item to the bin with the maximum product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the reciprocal of the sum of the rest capacity and the bin number\\n reciprocal_sum = 1 / (bins + np.arange(1, bins.size + 1))\\n\\n # Calculate the square root of the normalized rest capacity\\n normalized_rest_capacity = bins / np.max(bins)\\n sqrt_normalized_rest_capacity = np.sqrt(normalized_rest_capacity)\\n\\n # Calculate the score as the product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity\\n scores = reciprocal_sum * sqrt_normalized_rest_capacity\\n\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The score of a bin is determined by dividing the item size by the square root of the sum of the rest capacity and the bin number, multiplied by a constant representing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score of each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the score of each bin.\\n scores = (item / np.sqrt(bins + np.arange(len(bins)))) * np.sqrt(len(bins))\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score as the ratio of the item size to the bin capacity minus the bin number, rewarding bins with larger capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins - np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Increase the penalty factor for bins with remaining capacity greater than item size by a parameter 'k'.\\nCode:\\ndef new_score(item, bins, k):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > k * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-np.maximum(0, (bins - item) > item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the weighted sum of the item size and the rest capacity of the bins, with the weights being inversely proportional to the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function scores a set of bins to assign an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (numpy.array): The rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n numpy.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the weights for each bin.\\n weights = 1.0 / np.arange(1, len(bins) + 1)\\n\\n # Compute the scores for each bin.\\n scores = weights * (item + bins)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the minimum rest capacity, avoiding bins with rest capacity equal to the item size; If multiple bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have a rest capacity equal to the item size.\\n if np.any(bins == item):\\n return np.zeros_like(bins)\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin. Avoid bins with rest capacity equal to the item size.\\n scores = rest_capacities/bins\\n scores[rest_capacities == 0] = -np.inf\\n \\n # If any bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\\n max_capacity = np.max(bins[rest_capacities == np.min(rest_capacities)])\\n scores[bins == max_capacity] = np.inf\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score as the difference between bin capacity and the maximum capacity minus the item size multiplied by the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score as the difference between bin capacity and the maximum capacity minus the item size multiplied by the bin number.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_capacity = np.max(bins)\\n scores = bins - max_capacity + item * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by the reciprocal of the product of its index and the difference between its rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate scores for a set of bins.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin rest capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the product of the bin index and the difference.\\n scores = 1 / (np.arange(len(bins)) + 1) / diff\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: The new algorithm divides item size by bin's rest capacity, multiplies the fraction by a value less than 1, and adds 1 to the product.}\",\n \"code\": \"def score(item, bins):\\n scores = (item / bins) * 0.99 + 1\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the sum of the rest capacity and the bin number\\n inv_sum_rest_cap_bin_num = 1.0 / (bins + np.arange(1, bins.size + 1))\\n # Calculate the rest capacity divided by the maximum capacity\\n rest_cap_div_max_cap = bins / np.max(bins)\\n # Calculate the score\\n scores = inv_sum_rest_cap_bin_num - rest_cap_div_max_cap\\n # Return the scores\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n max_capacity = np.max(bins)\\n scores = (item / bins + np.sqrt(np.arange(len(bins)) + 1)) - (item / max_capacity)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates each bin's score as the sum of the square root of item size divided by the bin's capacity, square root of the bin's number, and square root of 1 divided by the bin's number, subtracting the bin's capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) + np.sqrt(np.arange(1, len(bins) + 1)) + np.sqrt(1 / np.arange(1, len(bins) + 1)) - bins / np.max(bins)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm main parameters: bin capacities and item size. New algorithm: Score function: scores = bins - (bins - item)**2\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - (bins - item)**2\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version: Calculate bin scores as the product of normalized capacity and the negative exponential of the bin number multiplied by the item size ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin scores for an item. The bin with the highest score should be assigned the item.\\n\\n Args:\\n item: int, size of the item to be assigned\\n bins: Numpy array, rest capacities of feasible bins\\n\\n Returns:\\n scores: Numpy array, scores for the bins\\n \\\"\\\"\\\"\\n\\n normalized_capacities = bins / np.max(bins)\\n exponential_weights = np.exp(-bins * item / np.max(bins))\\n scores = normalized_capacities * exponential_weights\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns the item to the bin with the maximum product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the reciprocal of the sum of the rest capacity and the bin number\\n reciprocal_sum = 1 / (bins + np.arange(1, bins.size + 1))\\n\\n # Calculate the square root of the normalized rest capacity\\n normalized_rest_capacity = bins / np.max(bins)\\n sqrt_normalized_rest_capacity = np.sqrt(normalized_rest_capacity)\\n\\n # Calculate the score as the product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity\\n scores = reciprocal_sum * sqrt_normalized_rest_capacity\\n\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The score of a bin is determined by dividing the item size by the square root of the sum of the rest capacity and the bin number, multiplied by a constant representing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score of each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the score of each bin.\\n scores = (item / np.sqrt(bins + np.arange(len(bins)))) * np.sqrt(len(bins))\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score as the ratio of the item size to the bin capacity minus the bin number, rewarding bins with larger capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins - np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Increase the penalty factor for bins with remaining capacity greater than item size by a parameter 'k'.\\nCode:\\ndef new_score(item, bins, k):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > k * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-np.maximum(0, (bins - item) > item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the weighted sum of the item size and the rest capacity of the bins, with the weights being inversely proportional to the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function scores a set of bins to assign an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (numpy.array): The rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n numpy.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the weights for each bin.\\n weights = 1.0 / np.arange(1, len(bins) + 1)\\n\\n # Compute the scores for each bin.\\n scores = weights * (item + bins)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign the item to the bin with the minimum rest capacity, avoiding bins with rest capacity equal to the item size; If multiple bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of assigning an item to each bin.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Check if any bins have a rest capacity equal to the item size.\\n if np.any(bins == item):\\n return np.zeros_like(bins)\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin. Avoid bins with rest capacity equal to the item size.\\n scores = rest_capacities/bins\\n scores[rest_capacities == 0] = -np.inf\\n \\n # If any bins have the same minimum rest capacity, assign the item to the one with the largest initial capacity.\\n max_capacity = np.max(bins[rest_capacities == np.min(rest_capacities)])\\n scores[bins == max_capacity] = np.inf\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by the reciprocal of the product of its index and the difference between its rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate scores for a set of bins.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin rest capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the product of the bin index and the difference.\\n scores = 1 / (np.arange(len(bins)) + 1) / diff\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculating each bin's score as the sum of the square root of the item size divided by the bin's capacity, square root of the bin's number, and square root of the bin's number divided by the item size, subtracting the square root of the maximum capacity divided by the bin's number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) + np.sqrt(np.arange(1, len(bins) + 1)) + np.sqrt(np.arange(1, len(bins) + 1) / item) - np.sqrt(np.max(bins) / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: The new algorithm divides item size by bin's rest capacity, multiplies the fraction by a value less than 1, and adds 1 to the product.}\",\n \"code\": \"def score(item, bins):\\n scores = (item / bins) * 0.99 + 1\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to penalize bins with large remaining capacities and/or small item sizes. The new algorithm scores each bin as the ratio of its remaining capacity to the sum of its index and the item size, exponentially penalized by the difference between the remaining capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n remaining_capacities = bins - item\\n index_arr = np.arange(len(bins))\\n scores = np.exp(-np.abs(remaining_capacities)) / (remaining_capacities + index_arr + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n max_capacity = np.max(bins)\\n scores = (item / bins + np.sqrt(np.arange(len(bins)) + 1)) - (item / max_capacity)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates each bin's score as the sum of the square root of item size divided by the bin's capacity, square root of the bin's number, and square root of 1 divided by the bin's number, subtracting the bin's capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) + np.sqrt(np.arange(1, len(bins) + 1)) + np.sqrt(1 / np.arange(1, len(bins) + 1)) - bins / np.max(bins)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm main parameters: bin capacities and item size. New algorithm: Score function: scores = bins - (bins - item)**2\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - (bins - item)**2\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (beta) * (1 / remaining_capacity) + (1 - beta) * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5\\n scores = (beta) * (1 / bins) + (1 - beta) * np.power(np.arange(1, len(bins) + 1), 1 / 3)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns the item to the bin with the maximum product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the reciprocal of the sum of the rest capacity and the bin number\\n reciprocal_sum = 1 / (bins + np.arange(1, bins.size + 1))\\n\\n # Calculate the square root of the normalized rest capacity\\n normalized_rest_capacity = bins / np.max(bins)\\n sqrt_normalized_rest_capacity = np.sqrt(normalized_rest_capacity)\\n\\n # Calculate the score as the product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity\\n scores = reciprocal_sum * sqrt_normalized_rest_capacity\\n\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" The score of a bin is determined by dividing the item size by the square root of the sum of the rest capacity and the bin number, multiplied by a constant representing bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Computes the score of each bin for assigning an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the score of each bin.\\n scores = (item / np.sqrt(bins + np.arange(len(bins)))) * np.sqrt(len(bins))\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the score as the ratio of the item size to the bin capacity minus the bin number, rewarding bins with larger capacities. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins - np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Increase the penalty factor for bins with remaining capacity greater than item size by a parameter 'k'.\\nCode:\\ndef new_score(item, bins, k):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > k * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-np.maximum(0, (bins - item) > item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the weighted sum of the item size and the rest capacity of the bins, with the weights being inversely proportional to the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function scores a set of bins to assign an item.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (numpy.array): The rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n numpy.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Compute the weights for each bin.\\n weights = 1.0 / np.arange(1, len(bins) + 1)\\n\\n # Compute the scores for each bin.\\n scores = weights * (item + bins)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Add a penalty to the score of any bin with remaining capacity greater than two times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inf = np.inf\\n scores = (bins - item) * (1-((bins - item) > 2 * item)) * 1e6\\n scores[bins == item] = inf\\n scores[bins < item] = -inf\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as 1e6 divided by the remaining capacity of the bin, subtracting a penalty if the capacity is less than three times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\n max_size = np.max(bins)\\n used_bins = np.where(bins>0)[0]\\n \\n weight1 = 1.0/(bins[used_bins] - item)\\n weight2 = np.where(bins[used_bins] < item * 3, -1e6, 0)\\n \\n scores = weight1 + weight2\\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^2 * (1-((bins - item) > 2 * item)) * (-1e6)\",\n \"code\": \"def score(item, bins):\\n scores = (bins - item)**2 * (1-((bins - item) > 2 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the inverse of the ratio of the item size to the maximum capacity, divided by the product of the square root of the bin's number and the ratio of the item size to the maximum capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n # Calculate the ratio of the item size to the bin's remaining capacity\\n ratio1 = item / (bins - item)\\n\\n # Calculate the inverse of the ratio of the item size to the maximum capacity\\n ratio2 = 1 / (item / bins)\\n\\n # Calculate the square root of the bin's number\\n sqrt_bin_num = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the ratio of the item size to the maximum capacity\\n ratio3 = item / bins\\n\\n # Calculate the score of each bin\\n scores = (ratio1 + ratio2) / (sqrt_bin_num * ratio3)\\n\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: (bins - item)^3 * (1-((bins - item) > 3 * item)) * (-1e6)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**3 * (1-((bins - item) > 3 * item)) * (-1e6)\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score is the ratio of item size to the rest capacity plus the bin number, penalizing bins with smaller rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores each bin by the reciprocal of the product of its index and the difference between its rest capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate scores for a set of bins.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin rest capacities and the item size.\\n diff = bins - item\\n\\n # Calculate the reciprocal of the product of the bin index and the difference.\\n scores = 1 / (np.arange(len(bins)) + 1) / diff\\n\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of each bin as the reciprocal of the product of the maximum bin capacity, the difference between the bin rest capacity and the item size, and the bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / (bins * (bins - item) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity minus the bin number, favoring bins with larger rest capacity.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / np.maximum(bins - item, 1)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score is the ratio of item size to the rest capacity plus the bin number divided by the maximum capacity, penalizing bins with smaller rest capacity and larger size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins - item) + bins / bins.max())\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (1 - alpha) * (1 / remaining_capacity) + alpha * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n alpha = 0.5\\n scores = (1 - alpha) * (1 / (bins - item)) + alpha * np.power(np.arange(len(bins)) + 1, 1 / 3)\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Assign score as 1e6 divided by the remaining capacity, penalizing bins with a capacity less than half the item size.\",\n \"code\": \"def score(item, bins):\\n scores = 1e6 / (bins - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to penalize bins with large remaining capacities and/or small item sizes. The new algorithm scores each bin as the ratio of its remaining capacity to the sum of its index and the item size, exponentially penalized by the difference between the remaining capacity and the item size.\",\n \"code\": \"def score(item, bins):\\n remaining_capacities = bins - item\\n index_arr = np.arange(len(bins))\\n scores = np.exp(-np.abs(remaining_capacities)) / (remaining_capacities + index_arr + 1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score of each bin as the sum of the item size divided by the bin's capacity and the square root of the bin's number, minus the item size divided by the maximum capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n max_capacity = np.max(bins)\\n scores = (item / bins + np.sqrt(np.arange(len(bins)) + 1)) - (item / max_capacity)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates each bin's score as the sum of the square root of item size divided by the bin's capacity, square root of the bin's number, and square root of 1 divided by the bin's number, subtracting the bin's capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item / bins) + np.sqrt(np.arange(1, len(bins) + 1)) + np.sqrt(1 / np.arange(1, len(bins) + 1)) - bins / np.max(bins)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the square root of the bin's number, divided by the ratio of the item size to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score of each bin as the sum of the ratio of the item size to the bin's remaining capacity and the square root of the bin's number, divided by the ratio of the item size to the maximum capacity.\\n\\n Parameters:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the ratio of the item size to the bin's remaining capacity.\\n ratios = item / bins\\n\\n # Calculate the square root of the bin's number.\\n sqrt_bins = np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = ratios + sqrt_bins / (item / np.max(bins))\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate the score for each bin based on the square root of the inverse of the sum of the rest capacity and the bin number, minus the rest capacity divided by the maximum capacity.\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Calculate the sum of rest capacity and bin number for each bin.\\n denom = bins + np.arange(1, len(bins) + 1)\\n\\n # Calculate the score for each bin.\\n scores = np.sqrt(1.0 / denom) - bins / np.max(bins)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm main parameters: bin capacities and item size. New algorithm: Score function: scores = bins - (bins - item)**2\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - (bins - item)**2\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm modifies the score function to: score = (beta) * (1 / remaining_capacity) + (1 - beta) * (cube root of bin number)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n beta = 0.5\\n scores = (beta) * (1 / bins) + (1 - beta) * np.power(np.arange(1, len(bins) + 1), 1 / 3)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm assigns the item to the bin with the maximum product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin in 'bins' for assigning an item of size 'item'.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.array): A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the reciprocal of the sum of the rest capacity and the bin number\\n reciprocal_sum = 1 / (bins + np.arange(1, bins.size + 1))\\n\\n # Calculate the square root of the normalized rest capacity\\n normalized_rest_capacity = bins / np.max(bins)\\n sqrt_normalized_rest_capacity = np.sqrt(normalized_rest_capacity)\\n\\n # Calculate the score as the product of the reciprocal of the sum of the rest capacity and the bin number, and the square root of the normalized rest capacity\\n scores = reciprocal_sum * sqrt_normalized_rest_capacity\\n\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the formula: score = (1 / (capacity - item)) if capacity != maximum capacity, else score = -1. Then, it will return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n maximum_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] != maximum_capacity:\\n scores[i] = 1 / (bins[i] - item)\\n else:\\n scores[i] = -1\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \" Calculate the score of a bin as the ratio of the item size to the rest capacity and add 1 to the ratio, and subtract 1 if the rest capacity is equal to the maximum capacity. \",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = (item / bins + 1) - (bins == bins.max())\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will prioritize bins with specific patterns in their rest capacities. The patterns are repeated but alternated by bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their rest capacities and item size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins.\\n\\n Returns:\\n np.array: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Pattern 1: Prioritize bins with rest capacity equal to item size\\n pattern1 = np.where(bins == item, np.full(bins.shape, 100), np.zeros(bins.shape))\\n\\n # Pattern 2: Prioritize bins with alternating rest capacities\\n pattern2 = np.where(bins % (item * 2) == item, np.full(bins.shape, 50), np.zeros(bins.shape))\\n\\n # Combine patterns\\n scores = pattern1 + pattern2\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the ratio of the item size to the square root of the rest capacity, adding 1 to ensure positive scores and subtracting 1 from bins at the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) * (item / np.sqrt(np.maximum(bins - item, 0)))\\n scores[bins == min(bins)] -= 1\\n scores[bins == max(bins)] += 1\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the inverse of the remaining capacity, and return the maximum score if the remaining capacity is less than a threshold, else return -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n threshold = bins.max() / 2\\n scores = 1.0 / np.maximum(bins - item, 1)\\n scores[bins < item] = -1\\n scores[bins <= threshold] = np.maximum(scores[bins <= threshold], -1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the rest capacity with the inverse of the bin index, and subtracts the negative maximum rest capacity from the product to adjust the score for the maximum capacity bin and set it to 0 if feasible and -1 if infeasible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculates the scores for each bin based on the item size and remaining bin capacities.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Array of remaining capacities for feasible bins.\\n\\n Returns:\\n Array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of remaining capacity and inverse bin index.\\n scores = bins * (1.0 / np.arange(1, len(bins) + 1))\\n\\n # Adjust scores for maximum capacity bin and infeasible bins.\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n scores[bins < item] = -1\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the product of the rest capacity and the exponential of the negative bin number, and increase the score by 1 if the rest capacity of a bin equals the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = bins * np.exp(-np.arange(len(bins)))\\n scores[bins == bins.max()] += 1\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm multiplies the rest capacity of a feasible bin with the reciprocal of the bin's index and adds a positive constant to encourage bin reuse.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function scores a set of bins to assign an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the reciprocal of the bin indices.\\n reciprocal_indices = 1 / np.arange(1, len(bins) + 1)\\n\\n # Calculate the scores.\\n scores = bins * reciprocal_indices + 1\\n\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates scores based on a weighted average of bin rest capacity, maximum bin capacity, and bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates scores for a set of bins to assign an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the bin number.\\n bin_number = np.arange(len(bins)) + 1\\n\\n # Calculate the scores.\\n scores = 0.5 * rest_capacities / max_capacity + 0.25 * bin_number + 0.25\\n\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" New algorithm: Calculate the scores for each bin by subtracting the item size from the rest capacity if it is less than the maximum capacity and the rest capacity is greater than the item size, and subtract 2 if the rest capacity is less than the maximum capacity or equals the item size. \",\n \"code\": \"def score(item, bins):\\n \\\"\\\"\\\"Calculate the scores for each bin by subtracting the item size from the rest capacity if it is less than the maximum capacity and the rest capacity is greater than the item size, and subtract 2 if the rest capacity is less than the maximum capacity or equals the item size.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = np.zeros_like(bins, dtype=np.float32)\\n max_capacity = np.max(bins)\\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity < max_capacity and bin_capacity > item:\\n scores[i] = max_capacity - item - bin_capacity\\n else:\\n scores[i] = -2\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm will use a weighted average of the bin capacity, the bin rest capacity, the bin number, and a penalty factor to assign an item to an empty bin that results in the lowest final score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest = np.maximum(bins - item, 0)\\n scores = (-rest + bins*0.5 - (bins - rest)**0.5 - rest**0.5)*0.25\\n scores[bins <= item] = -np.inf\\n scores[rest == 0] = -np.inf\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{ New algorithm: Calculate the scores for each bin by subtracting 1 from the rest capacity if it is less than the maximum capacity, subtracting 2 if it is equal to the maximum capacity, and subtracting 3 if the rest capacity is less than the item size. }\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(\\n bins < item,\\n -3,\\n np.where(bins == item, -2, -1 * np.minimum(1, bins - item - 1))\\n )\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by subtracting 1 from the rest capacity if it is less than the maximum capacity and subtracting 2 if it is equal to the maximum capacity, and set the score to 0 if the rest capacity is less than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the scores for each bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = np.zeros_like(bins)\\n mask = bins >= item\\n scores[mask] = np.where(bins[mask] == item, -2, -1)\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio of the item size to the bin's rest capacity, penalized by the number of bins that can fit the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([[-1.]])\\n ratios = item / bins\\n penalty = 1 / (np.sum(ratios < 1) + 1)\\n scores = penalty * ratios\\n scores[np.argmax(scores)] = 0.\\n return scores\",\n \"objective\": 0.05654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with minimum remaining capacity and higher capacity, then penalize full bins to minimize used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Prioritize bins with minimum remaining capacity and higher capacity, then penalize full bins to minimize used bins.\\n\\n Args:\\n item (int): Size of the current item.\\n bins (np.ndarray): Remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n # Prioritize bins with minimum remaining capacity.\\n scores = 1 / bins\\n\\n # Penalize full bins to minimize used bins.\\n full_bins = bins <= item\\n scores[full_bins] = -np.inf\\n\\n # Prioritize bins with higher capacity.\\n scores = np.where(full_bins, scores, scores * bins)\\n\\n return scores\",\n \"objective\": 0.06751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with its index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the square root of the bin's size.\\n sqrt_size = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with its index.\\n exp_product = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * sqrt_size * exp_product\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with small remaining capacity and penalize bins with large differences between their remaining capacity and the item size by using the score function: scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Prioritize bins with small remaining capacity and penalize bins with large differences between their remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (numpy.ndarray): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n numpy.ndarray: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0)))\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin score.\\n\\n Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = 1.0 / available_capacity**2 + np.sqrt(available_capacity / item) / np.arange(1.0, len(bins) + 1.0)\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a score function that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes a score for each bin that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array containing the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array containing the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the rest capacity ratio for each bin.\\n ratio = bins / item\\n\\n # Compute the score for each bin.\\n scores = ratio / (np.arange(len(bins)) + 1)\\n\\n # Penalize bins with a low rest capacity ratio.\\n scores[ratio < 1.5] /= ratio[ratio < 1.5]\\n\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses the product of the bins' inverse index, the inverse of the bins' available capacity, and a weighted sum of the item size and the bin size as the score function.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = bins / (np.array(range(len(bins))) + 1) * (1/(bins - item) + 1./item + 1.)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Assign each bin a score that is the sum of the inverse of the square of the difference between the bin's size and the item's size, and the inverse of the product of the bin's rest capacity and its index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1 / (bins - item) ** 2 + 1 / (bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse square root of the distance between the item size and the bin's rest capacity and the square of the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(1 / (bins - item))**2 * 1 / np.arange(len(bins),0,-1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score function is the product of inverse square root of the bin available capacity, the inverse of the square root of the bin index, and the bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = (1 / np.sqrt(available_capacity)) * (1 / np.sqrt(np.arange(1, len(bins) + 1))) * item\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin score as the product of the exponent of the inverse of the difference between the bin size and the item size, and the exponent of the inverse of the product of the bin size and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.power(1 / (bins - item), 2) * np.power(1 / (bins * np.arange(1, len(bins) + 1)), 2)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the following: the inverse of the square of the difference between the item size and the bin's rest capacity, the inverse of the product of the bin's index and its rest capacity, and the square of the bin's size.\",\n \"code\": \"def score(item, bins):\\n # Calculate the score for each bin\\n scores = (1 / ((item - bins) ** 2)) * (1 / (np.arange(1, bins.size + 1) * bins)) * (bins ** 2)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's rest capacity, and the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diffs = np.abs(bins - item)\\n # Calculate the inverse of the square of the absolute difference\\n inv_sq_diffs = 1 / diffs**2\\n # Calculate the square root of the bin's rest capacity\\n sqrt_capacities = np.sqrt(bins)\\n # Calculate the inverse of the bin's index\\n inv_indices = 1 / np.arange(1, bins.size + 1)\\n # Calculate the score for each bin\\n scores = inv_sq_diffs * sqrt_capacities * inv_indices\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index and the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin score for an item.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n available_capacity = np.maximum(bins - item, 0)\\n ratio = np.maximum(available_capacity / item, 1)\\n scores = (1 / available_capacity**2 + np.sqrt(ratio)) / np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the absolute difference between the item size and the bin's rest capacity\\n inv_diff = 1 / np.abs(item - bins)\\n\\n # Calculate the square root of the bin's rest capacity\\n sqrt_cap = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index\\n exp_cap_idx = np.exp(bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the score for each bin\\n scores = inv_diff * sqrt_cap * exp_cap_idx\\n\\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of inverse of distance between item size and bin's rest capacity, inverse of distance between bin index and item size, and square root of bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n distance_size = np.abs(bins - item)\\n distance_index = np.abs(np.arange(len(bins)) - item)\\n scores = 1 / distance_size + 1 / distance_index + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritize bins with small remaining capacity and penalize bins with large differences between their remaining capacity and the item size by using the score function: scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Prioritize bins with small remaining capacity and penalize bins with large differences between their remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (numpy.ndarray): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n numpy.ndarray: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0)))\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin score.\\n\\n Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = 1.0 / available_capacity**2 + np.sqrt(available_capacity / item) / np.arange(1.0, len(bins) + 1.0)\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the sum of the inverse of the rest capacity, the logarithm of the rest capacity, and the square root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n\\n # Calculate the logarithm of the rest capacity\\n log_rest_capacity = np.log(bins - item)\\n\\n # Calculate the square root of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score for each bin\\n scores = inv_rest_capacity + log_rest_capacity + sqrt_bin_index\\n\\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a score function that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes a score for each bin that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array containing the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array containing the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the rest capacity ratio for each bin.\\n ratio = bins / item\\n\\n # Compute the score for each bin.\\n scores = ratio / (np.arange(len(bins)) + 1)\\n\\n # Penalize bins with a low rest capacity ratio.\\n scores[ratio < 1.5] /= ratio[ratio < 1.5]\\n\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses the product of the bins' inverse index, the inverse of the bins' available capacity, and a weighted sum of the item size and the bin size as the score function.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = bins / (np.array(range(len(bins))) + 1) * (1/(bins - item) + 1./item + 1.)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Assign each bin a score that is the sum of the inverse of the square of the difference between the bin's size and the item's size, and the inverse of the product of the bin's rest capacity and its index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1 / (bins - item) ** 2 + 1 / (bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse square root of the distance between the item size and the bin's rest capacity and the square of the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(1 / (bins - item))**2 * 1 / np.arange(len(bins),0,-1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score function is the product of inverse square root of the bin available capacity, the inverse of the square root of the bin index, and the bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = (1 / np.sqrt(available_capacity)) * (1 / np.sqrt(np.arange(1, len(bins) + 1))) * item\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin score as the product of the exponent of the inverse of the difference between the bin size and the item size, and the exponent of the inverse of the product of the bin size and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.power(1 / (bins - item), 2) * np.power(1 / (bins * np.arange(1, len(bins) + 1)), 2)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the following: the inverse of the square of the difference between the item size and the bin's rest capacity, the inverse of the product of the bin's index and its rest capacity, and the square of the bin's size.\",\n \"code\": \"def score(item, bins):\\n # Calculate the score for each bin\\n scores = (1 / ((item - bins) ** 2)) * (1 / (np.arange(1, bins.size + 1) * bins)) * (bins ** 2)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the absolute difference between the item size and the bin's rest capacity\\n inv_diff = 1 / np.abs(item - bins)\\n\\n # Calculate the square root of the bin's rest capacity\\n sqrt_cap = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index\\n exp_cap_idx = np.exp(bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the score for each bin\\n scores = inv_diff * sqrt_cap * exp_cap_idx\\n\\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the square of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n score_fun = lambda b: (1 / np.sqrt(np.abs(item-b))) * ((b**2) * np.exp(b * ((b**2)/100)))\\n scores = score_fun(bins)\\n return scores\",\n \"objective\": 0.02445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of inverse of distance between item size and bin's rest capacity, inverse of distance between bin index and item size, and square root of bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n distance_size = np.abs(bins - item)\\n distance_index = np.abs(np.arange(len(bins)) - item)\\n scores = 1 / distance_size + 1 / distance_index + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Evaulate the bin score using the square root function proposed as the score function: scores = np.sqrt(1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0)))) \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining = bins - item\\n scores = np.sqrt(1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0))))\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin score.\\n\\n Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = 1.0 / available_capacity**2 + np.sqrt(available_capacity / item) / np.arange(1.0, len(bins) + 1.0)\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the sum of the inverse of the rest capacity, the logarithm of the rest capacity, and the square root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n\\n # Calculate the logarithm of the rest capacity\\n log_rest_capacity = np.log(bins - item)\\n\\n # Calculate the square root of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score for each bin\\n scores = inv_rest_capacity + log_rest_capacity + sqrt_bin_index\\n\\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Bin score is derived from the product of the bin's remaining capacity raised to the power of the bin's index divided by the absolute difference between bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = np.power(bins, np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Set the scores of bins with insufficient capacity to zero\\n scores[bins < item] = 0\\n\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a bin's score using the sum of inverse of its remaining capacity and the square of the difference between the item and bin size with an exponential weight of bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity\\n inv_cap = 1 / (bins - item)\\n \\n # Calculate the squared difference between the item and bin size\\n diff_sq = np.square(item - bins)\\n \\n # Calculate the exponential weight of the bin's index\\n exp_weight = np.exp(np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = inv_cap * diff_sq * exp_weight\\n \\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses the product of the bins' inverse index, the inverse of the bins' available capacity, and a weighted sum of the item size and the bin size as the score function.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = bins / (np.array(range(len(bins))) + 1) * (1/(bins - item) + 1./item + 1.)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Assign each bin a score that is the sum of the inverse of the square of the difference between the bin's size and the item's size, and the inverse of the product of the bin's rest capacity and its index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1 / (bins - item) ** 2 + 1 / (bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the sum of the inverse square root of the distance between the item size and the bin's rest capacity and the square of the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(1 / (bins - item))**2 * 1 / np.arange(len(bins),0,-1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Calculates bin score as the product of the inverse of bin index, the inverse of bin available capacity raised to a power, and a function of item size.\",\n \"code\": \"def score(item, bins):\\n scores = (1 / np.arange(1, bins.size + 1)) * (1 / (bins - item) ** 2) * (bins - item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the inverse of the absolute difference between the item size and the bin's rest capacity\\n inv_diff = 1 / np.abs(item - bins)\\n \\n # Calculate the square root of the bin's size\\n sqrt_size = np.sqrt(bins)\\n \\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\\n exp_prod = np.exp(bins * np.arange(len(bins)) - item / 2)\\n \\n # Calculate the final score for each bin\\n scores = inv_diff * sqrt_size * exp_prod\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the absolute difference between the item size and the bin's rest capacity\\n inv_diff = 1 / np.abs(item - bins)\\n\\n # Calculate the square root of the bin's rest capacity\\n sqrt_cap = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index\\n exp_cap_idx = np.exp(bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the score for each bin\\n scores = inv_diff * sqrt_cap * exp_cap_idx\\n\\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the square of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n score_fun = lambda b: (1 / np.sqrt(np.abs(item-b))) * ((b**2) * np.exp(b * ((b**2)/100)))\\n scores = score_fun(bins)\\n return scores\",\n \"objective\": 0.02445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Weighted sum of inverse of distance between item size and bin's rest capacity, inverse of distance between bin index and item size, and square root of bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item.\\n\\n In each step, the item will be assigned to the bin with the maximum score.\\n If the rest capacity of a bin equals the maximum capacity, it will not be used.\\n The final goal is to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n distance_size = np.abs(bins - item)\\n distance_index = np.abs(np.arange(len(bins)) - item)\\n scores = 1 / distance_size + 1 / distance_index + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Evaulate the bin score using the square root function proposed as the score function: scores = np.sqrt(1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0)))) \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining = bins - item\\n scores = np.sqrt(1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0))))\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin score.\\n\\n Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = 1.0 / available_capacity**2 + np.sqrt(available_capacity / item) / np.arange(1.0, len(bins) + 1.0)\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin as the sum of the inverse of the rest capacity, the logarithm of the rest capacity, and the square root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the rest capacity\\n inv_rest_capacity = 1 / (bins - item)\\n\\n # Calculate the logarithm of the rest capacity\\n log_rest_capacity = np.log(bins - item)\\n\\n # Calculate the square root of the bin's index\\n sqrt_bin_index = np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score for each bin\\n scores = inv_rest_capacity + log_rest_capacity + sqrt_bin_index\\n\\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Bin score is derived from the product of the bin's remaining capacity raised to the power of the bin's index divided by the absolute difference between bin's remaining capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the bin scores\\n scores = np.power(bins, np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Set the scores of bins with insufficient capacity to zero\\n scores[bins < item] = 0\\n\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate a bin's score using the sum of inverse of its remaining capacity and the square of the difference between the item and bin size with an exponential weight of bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the remaining capacity\\n inv_cap = 1 / (bins - item)\\n \\n # Calculate the squared difference between the item and bin size\\n diff_sq = np.square(item - bins)\\n \\n # Calculate the exponential weight of the bin's index\\n exp_weight = np.exp(np.arange(len(bins)))\\n \\n # Calculate the score for each bin\\n scores = inv_cap * diff_sq * exp_weight\\n \\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses the product of the bins' inverse index, the inverse of the bins' available capacity, and a weighted sum of the item size and the bin size as the score function.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = bins / (np.array(range(len(bins))) + 1) * (1/(bins - item) + 1./item + 1.)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Assign each bin a score that is the sum of the inverse of the square of the difference between the bin's size and the item's size, and the inverse of the product of the bin's rest capacity and its index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1 / (bins - item) ** 2 + 1 / (bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the bin score based on the product of the inverse of the rest capacity, the square root of the bin size, and the exponential of the product of the rest capacity and its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the bin score based on the product of the inverse of the rest capacity, the square root of the bin size, and the exponential of the product of the rest capacity and its index.\\n \\n Args:\\n item (int): The size of the current item.\\n bins (NumPy array): The rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n NumPy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the inverse of the rest capacity of each bin.\\n inv_rest_capacities = 1 / rest_capacities\\n\\n # Calculate the square root of the bin size.\\n bin_sizes = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the rest capacity and its index.\\n exp_rest_capacities = np.exp(rest_capacities * np.arange(1, len(bins) + 1))\\n\\n # Calculate the bin score.\\n scores = inv_rest_capacities * bin_sizes * exp_rest_capacities\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the inverse of the absolute difference between the item size and the bin's rest capacity\\n inv_diff = 1 / np.abs(item - bins)\\n \\n # Calculate the square root of the bin's size\\n sqrt_size = np.sqrt(bins)\\n \\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\\n exp_prod = np.exp(bins * np.arange(len(bins)) - item / 2)\\n \\n # Calculate the final score for each bin\\n scores = inv_diff * sqrt_size * exp_prod\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of the absolute difference between the item size and the bin's rest capacity\\n inv_diff = 1 / np.abs(item - bins)\\n\\n # Calculate the square root of the bin's rest capacity\\n sqrt_cap = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index\\n exp_cap_idx = np.exp(bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the score for each bin\\n scores = inv_diff * sqrt_cap * exp_cap_idx\\n\\n # Return the scores\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the square of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n score_fun = lambda b: (1 / np.sqrt(np.abs(item-b))) * ((b**2) * np.exp(b * ((b**2)/100)))\\n scores = score_fun(bins)\\n return scores\",\n \"objective\": 0.02445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm employs a weighted sum of inverse of distance between item size and rest capacity, inverse of distance between bin index and item size, and a square root of bin's rest capacity, and the item size, with all parameters being scalars.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Scores a set of bins to assign an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of feasible bins.\\n\\n Returns:\\n A Numpy array of scores for the bins.\\n \\\"\\\"\\\"\\n\\n distance_to_capacity = np.abs(bins - item)\\n distance_to_index = np.abs(np.arange(len(bins)) - item)\\n scores = 1 / distance_to_capacity + 1 / distance_to_index + np.sqrt(bins) + item\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New Algorithm: Multiply the item size by the square of the exponential of the product of the bin's rest capacity and its index, and then divide the result by the distance between the item size and the bin's rest capacity. If the rest capacity of a bin is zero, it will not be used.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.square(np.exp(bins * np.arange(1, len(bins) + 1)))) / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.02827,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the square of the exponential of the product of the bin's rest capacity and its index, and the sum of the inverse of the distance between the item size and the bin's rest capacity and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_prod_rest_capacity_index = np.exp(np.multiply(bins, np.arange(1, len(bins) + 1)))\\n\\n # Calculate the inverse of the distance between the item size and the bin's rest capacity\\n inv_distance_item_rest_capacity = 1 / np.abs(bins - item)\\n\\n # Calculate the square root of the bin's size\\n sqrt_bin_size = np.sqrt(bins)\\n\\n # Calculate the sum of the inverse of the distance between the item size and the bin's rest\\n # capacity and the square root of the bin's size\\n sum_inv_distance_item_rest_capacity_sqrt_bin_size = np.sum(\\n np.multiply(inv_distance_item_rest_capacity, sqrt_bin_size)\\n )\\n\\n # Calculate the score for each bin\\n scores = np.multiply(np.square(exp_prod_rest_capacity_index), sum_inv_distance_item_rest_capacity_sqrt_bin_size)\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Evaulate the bin score using the square root function proposed as the score function: scores = np.sqrt(1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0)))) \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining = bins - item\\n scores = np.sqrt(1. / ((1. + remaining) * (1. + np.abs(remaining - item)) * (1. + np.maximum(remaining - item, 0))))\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the square of the inverse of the distance between the item size and the bin's rest capacity, the cube of the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the square of the inverse of the distance between the item size and the bin's rest capacity.\\n dist_inv_squared = np.square(1 / np.abs(bins - item))\\n\\n # Calculate the cube of the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_cubed = np.power(np.exp(bins * np.arange(1, len(bins) + 1)), 3)\\n\\n # Calculate the square of the bin's size.\\n size_squared = np.square(bins)\\n\\n # Calculate the scores as the sum of the three components.\\n scores = dist_inv_squared + exp_prod_cubed + size_squared\\n\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the square of the rest capacity minus the item size, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity minus the item size\\n rest_capacity = bins - item\\n\\n # Calculate the inverse of the square of the rest capacity\\n inv_rest_capacity = 1 / (rest_capacity ** 2)\\n\\n # Calculate the square root of the bin's size\\n sqrt_bin_size = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index\\n exp_rest_capacity_index = np.exp(rest_capacity * np.arange(len(bins)))\\n\\n # Calculate the scores\\n scores = inv_rest_capacity * sqrt_bin_size * exp_rest_capacity_index\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: For each item, multiply the sum of the square of the exponential of the square root of bin's capacity and its index, the square of the inverse of the absolute difference between item size and rest capacity, and the exponential of the product of bin's capacity with its index minus half of item size, by an integer that is exponential of the difference between item size and bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of the feasible bins\\n\\n Returns:\\n scores: The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Calculate the exponentials of the square root of bin capacities and their indices.\\n exp_cap_sqrt = np.exp(np.sqrt(bins))\\n\\n # Calculate the exponentials of the square root of bin indices.\\n exp_idx_sqrt = np.exp(np.sqrt(np.arange(1, len(bins) + 1)))\\n\\n # Calculate the squares of the inverse of the absolute difference between item size and rest capacity.\\n inv_diff_sqr = (1 / np.abs(item - bins)) ** 2\\n\\n # Calculate the exponentials of the product of bin capacities with their indices minus half of item size.\\n exp_cap_idx_item = np.exp(bins * np.arange(1, len(bins) + 1) - item / 2)\\n\\n # Calculate the scores.\\n scores = (exp_cap_sqrt * exp_idx_sqrt * inv_diff_sqr * exp_cap_idx_item) * np.exp(item - bins)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of the inverse of the absolute difference between the item size and the bin's rest capacity\\n inv_diff = 1 / np.abs(item - bins)\\n \\n # Calculate the square root of the bin's size\\n sqrt_size = np.sqrt(bins)\\n \\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\\n exp_prod = np.exp(bins * np.arange(len(bins)) - item / 2)\\n \\n # Calculate the final score for each bin\\n scores = inv_diff * sqrt_size * exp_prod\\n \\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(1.0 / np.abs(item - bins), np.sqrt(bins)) * np.exp(bins * np.arange(bins.shape[0]))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the square of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n score_fun = lambda b: (1 / np.sqrt(np.abs(item-b))) * ((b**2) * np.exp(b * ((b**2)/100)))\\n scores = score_fun(bins)\\n return scores\",\n \"objective\": 0.02445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The bin score is calculated based on the product of the inverse of the rest capacity, the square root of the bin size, and the exponential of the product of the rest capacity and the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1./(bins - item)**2 * np.sqrt(bins)*np.exp(bins*np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm employs a weighted sum of inverse of distance between item size and rest capacity, inverse of distance between bin index and item size, and a square root of bin's rest capacity, with all parameters being different from the original algorithm.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n distance1 = np.abs(bins - item)\\n distance2 = np.abs(np.arange(len(bins)) - item)\\n scores = 1 / distance1 + 1 / distance2 + np.sqrt(bins)\\n scores[bins <= 0] = 0.\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New Algorithm: Multiply the item size by the square of the exponential of the product of the bin's rest capacity and its index, and then divide the result by the distance between the item size and the bin's rest capacity. If the rest capacity of a bin is zero, it will not be used.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.square(np.exp(bins * np.arange(1, len(bins) + 1)))) / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.02827,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score function multiplies the sum of the exponential of the bin size and the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's index, and the exponential of the product between the item size and the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score function to assign an item to a bin.\\n\\n Args:\\n item (int): Size of the item to be assigned.\\n bins (np.ndarray): Rest capacities of feasible bins, must be larger than the item size.\\n\\n Returns:\\n np.ndarray: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the sum of the exponential of the bin size and the inverse of the absolute difference between the item size and the bin's rest capacity\\n num = np.exp(bins) + 1 / np.abs(bins - item)\\n\\n # Calculate the square root of the bin's index\\n idx = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the exponential of the product between the item size and the bin's index\\n denom = np.exp(item * idx)\\n\\n # Calculate the score\\n scores = num / denom\\n return scores\",\n \"objective\": 0.02837,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the square of the rest capacity minus the item size, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the rest capacity minus the item size\\n rest_capacity = bins - item\\n\\n # Calculate the inverse of the square of the rest capacity\\n inv_rest_capacity = 1 / (rest_capacity ** 2)\\n\\n # Calculate the square root of the bin's size\\n sqrt_bin_size = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with the bin's index\\n exp_rest_capacity_index = np.exp(rest_capacity * np.arange(len(bins)))\\n\\n # Calculate the scores\\n scores = inv_rest_capacity * sqrt_bin_size * exp_rest_capacity_index\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(bins, np.exp(np.multiply(rest_capacities, np.arange(1, len(rest_capacities) + 1)))) / np.abs(rest_capacities)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: For each item, multiply the sum of the square of the exponential of the square root of bin's capacity and its index, the square of the inverse of the absolute difference between item size and rest capacity, and the exponential of the product of bin's capacity with its index minus half of item size, by an integer that is exponential of the difference between item size and bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin.\\n\\n Args:\\n item: The size of the current item.\\n bins: The remaining capacities of the feasible bins\\n\\n Returns:\\n scores: The scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Calculate the exponentials of the square root of bin capacities and their indices.\\n exp_cap_sqrt = np.exp(np.sqrt(bins))\\n\\n # Calculate the exponentials of the square root of bin indices.\\n exp_idx_sqrt = np.exp(np.sqrt(np.arange(1, len(bins) + 1)))\\n\\n # Calculate the squares of the inverse of the absolute difference between item size and rest capacity.\\n inv_diff_sqr = (1 / np.abs(item - bins)) ** 2\\n\\n # Calculate the exponentials of the product of bin capacities with their indices minus half of item size.\\n exp_cap_idx_item = np.exp(bins * np.arange(1, len(bins) + 1) - item / 2)\\n\\n # Calculate the scores.\\n scores = (exp_cap_sqrt * exp_idx_sqrt * inv_diff_sqr * exp_cap_idx_item) * np.exp(item - bins)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, and the square root of the bin's size}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.abs(bins - item) + np.exp(bins * np.arange(len(bins)) - 0.5 * item) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp = np.exp(np.multiply(bins, np.arange(len(bins))))\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(np.multiply(bins, exp), 1 / diff)\\n\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(1.0 / np.abs(item - bins), np.sqrt(bins)) * np.exp(bins * np.arange(bins.shape[0]))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is calculated based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the product of the bin's rest capacity and its index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Check if any bin has enough capacity to hold the item.\\n if np.min(bins) < item:\\n return np.zeros_like(bins)\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the square root of the exponential of the product of the bin's rest capacity and its index.\\n sqrt_exp_prod_bin_capacity_index = np.sqrt(np.exp(bins * np.arange(1, len(bins) + 1)))\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index minus half of the item size.\\n exp_prod_bin_capacity_index_minus_half_item_size = np.exp(bins * np.arange(1, len(bins) + 1) - item / 2)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * sqrt_exp_prod_bin_capacity_index * exp_prod_bin_capacity_index_minus_half_item_size\\n\\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the square of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n score_fun = lambda b: (1 / np.sqrt(np.abs(item-b))) * ((b**2) * np.exp(b * ((b**2)/100)))\\n scores = score_fun(bins)\\n return scores\",\n \"objective\": 0.02445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The bin score is calculated based on the product of the inverse of the rest capacity, the square root of the bin size, and the exponential of the product of the rest capacity and the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1./(bins - item)**2 * np.sqrt(bins)*np.exp(bins*np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm employs a weighted sum of inverse of distance between item size and rest capacity, inverse of distance between bin index and item size, and a square root of bin's rest capacity, with all parameters being different from the original algorithm.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n distance1 = np.abs(bins - item)\\n distance2 = np.abs(np.arange(len(bins)) - item)\\n scores = 1 / distance1 + 1 / distance2 + np.sqrt(bins)\\n scores[bins <= 0] = 0.\\n return scores\",\n \"objective\": 0.02546,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New Algorithm: Multiply the item size by the square of the exponential of the product of the bin's rest capacity and its index, and then divide the result by the distance between the item size and the bin's rest capacity. If the rest capacity of a bin is zero, it will not be used.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * np.square(np.exp(bins * np.arange(1, len(bins) + 1)))) / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.02827,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(bins, np.exp(np.multiply(rest_capacities, np.arange(1, len(rest_capacities) + 1)))) / np.abs(rest_capacities)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, and the square root of the bin's size}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.abs(bins - item) + np.exp(bins * np.arange(len(bins)) - 0.5 * item) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp = np.exp(np.multiply(bins, np.arange(len(bins))))\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(np.multiply(bins, exp), 1 / diff)\\n\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(1.0 / np.abs(item - bins), np.sqrt(bins)) * np.exp(bins * np.arange(bins.shape[0]))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity, and the bin index.\",\n \"code\": \"def score(item, bins):\\n scores = bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins - item) + 1) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is calculated based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the product of the bin's rest capacity and its index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Check if any bin has enough capacity to hold the item.\\n if np.min(bins) < item:\\n return np.zeros_like(bins)\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the square root of the exponential of the product of the bin's rest capacity and its index.\\n sqrt_exp_prod_bin_capacity_index = np.sqrt(np.exp(bins * np.arange(1, len(bins) + 1)))\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index minus half of the item size.\\n exp_prod_bin_capacity_index_minus_half_item_size = np.exp(bins * np.arange(1, len(bins) + 1) - item / 2)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * sqrt_exp_prod_bin_capacity_index * exp_prod_bin_capacity_index_minus_half_item_size\\n\\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's rest capacity with the square of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n score_fun = lambda b: (1 / np.sqrt(np.abs(item-b))) * ((b**2) * np.exp(b * ((b**2)/100)))\\n scores = score_fun(bins)\\n return scores\",\n \"objective\": 0.02445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The bin score is calculated based on the product of the inverse of the rest capacity, the square root of the bin size, and the exponential of the product of the rest capacity and the square root of its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1./(bins - item)**2 * np.sqrt(bins)*np.exp(bins*np.sqrt(np.arange(1, len(bins)+1)))\\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(bins, np.exp(np.multiply(rest_capacities, np.arange(1, len(rest_capacities) + 1)))) / np.abs(rest_capacities)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A comprehensive score that combines the geometric mean of the bin's size and rest capacity, the exponential of the product of the bin's index and rest capacity, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item to.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are\\n larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n size_rest_capacity_gm = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n index_rest_capacity_exp = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the inverse of the absolute difference between the item size and the\\n # bin's rest capacity.\\n item_rest_capacity_diff_inv = 1 / np.abs(bins - item)\\n\\n # Combine the three scores into a comprehensive score.\\n scores = size_rest_capacity_gm * index_rest_capacity_exp * item_rest_capacity_diff_inv\\n\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, and the square root of the bin's size}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.abs(bins - item) + np.exp(bins * np.arange(len(bins)) - 0.5 * item) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp = np.exp(np.multiply(bins, np.arange(len(bins))))\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(np.multiply(bins, exp), 1 / diff)\\n\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(1.0 / np.abs(item - bins), np.sqrt(bins)) * np.exp(bins * np.arange(bins.shape[0]))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity, and the bin index.\",\n \"code\": \"def score(item, bins):\\n scores = bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins - item) + 1) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score for each bin is calculated based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the product of the bin's rest capacity and its index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin for assigning an item.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Check if any bin has enough capacity to hold the item.\\n if np.min(bins) < item:\\n return np.zeros_like(bins)\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the square root of the exponential of the product of the bin's rest capacity and its index.\\n sqrt_exp_prod_bin_capacity_index = np.sqrt(np.exp(bins * np.arange(1, len(bins) + 1)))\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index minus half of the item size.\\n exp_prod_bin_capacity_index_minus_half_item_size = np.exp(bins * np.arange(1, len(bins) + 1) - item / 2)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * sqrt_exp_prod_bin_capacity_index * exp_prod_bin_capacity_index_minus_half_item_size\\n\\n return scores\",\n \"objective\": 0.02083,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Combining the ideas of prioritizing bins based on their remaining capacity and penalizing bins with large differences between their remaining capacity and the item size, the new algorithm assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n This function assigns a score to each bin as the product of the inverse of the square root of the bin's remaining capacity and the inverse of the absolute difference between the bin's remaining capacity and the item size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the remaining capacity of each bin after assigning the item.\\n remaining_capacities = bins - item\\n\\n # Calculate the inverse of the square root of the remaining capacity of each bin.\\n inverse_sqrt_remaining_capacities = 1 / np.sqrt(remaining_capacities)\\n\\n # Calculate the absolute difference between the remaining capacity of each bin and the item size.\\n abs_differences = np.abs(remaining_capacities - item)\\n\\n # Calculate the inverse of the absolute difference between the remaining capacity of each bin and the item size.\\n inverse_abs_differences = 1 / abs_differences\\n\\n # Calculate the score for each bin as the product of the inverse of the square root of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size.\\n scores = inverse_sqrt_remaining_capacities * inverse_abs_differences\\n\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacities = bins - item\\n scores = rest_capacities * np.exp(rest_capacities * np.arange(len(bins))) * (1 / np.abs(rest_capacities)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(bins, np.exp(np.multiply(rest_capacities, np.arange(1, len(rest_capacities) + 1)))) / np.abs(rest_capacities)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the existing algorithm include: inverse function, exponent, and bin size square. The new algorithm uses the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cube of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the cube of the bin's size.\\n cube_size = np.power(bins, 3)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_cap_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A comprehensive score that combines the geometric mean of the bin's size and rest capacity, the exponential of the product of the bin's index and rest capacity, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item to.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are\\n larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n size_rest_capacity_gm = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n index_rest_capacity_exp = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the inverse of the absolute difference between the item size and the\\n # bin's rest capacity.\\n item_rest_capacity_diff_inv = 1 / np.abs(bins - item)\\n\\n # Combine the three scores into a comprehensive score.\\n scores = size_rest_capacity_gm * index_rest_capacity_exp * item_rest_capacity_diff_inv\\n\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, and the square root of the bin's size}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.abs(bins - item) + np.exp(bins * np.arange(len(bins)) - 0.5 * item) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp = np.exp(np.multiply(bins, np.arange(len(bins))))\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(np.multiply(bins, exp), 1 / diff)\\n\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(1.0 / np.abs(item - bins), np.sqrt(bins)) * np.exp(bins * np.arange(bins.shape[0]))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity, and the bin index.\",\n \"code\": \"def score(item, bins):\\n scores = bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins - item) + 1) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher rest capacity and penalizes bins with rest capacity much larger than item size and equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n\\n # Find feasible bins that can hold the 'item'.\\n feasible_bins = bins[bins >= item]\\n \\n if len(feasible_bins) == 0:\\n return np.zeros_like(bins)\\n \\n # Calculate the rest capacity after assigning the 'item'.\\n rest_capacities = feasible_bins - item\\n \\n # Calculate the score for each feasible bin.\\n scores = 1 / (rest_capacities + 1)\\n \\n # Penalize bins with rest capacity much larger than item size or equal to the maximum capacity.\\n max_capacity = np.max(bins)\\n scores -= (rest_capacities > max_capacity - item) * 0.5\\n scores -= (rest_capacities > item) * 0.25\\n \\n # Normalize the scores.\\n scores /= np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version that calculates the ratio of the item to the bin capacity and penalizes full bins more harshly using a logarithmic function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 - np.power(1 - item / bins, 2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will prioritize bins with specific patterns in their rest capacities. The patterns are repeated but alternated by bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their rest capacities and item size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins.\\n\\n Returns:\\n np.array: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Pattern 1: Prioritize bins with rest capacity equal to item size\\n pattern1 = np.where(bins == item, np.full(bins.shape, 100), np.zeros(bins.shape))\\n\\n # Pattern 2: Prioritize bins with alternating rest capacities\\n pattern2 = np.where(bins % (item * 2) == item, np.full(bins.shape, 50), np.zeros(bins.shape))\\n\\n # Combine patterns\\n scores = pattern1 + pattern2\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A score function that prioritized bins based on the ratio of their rest capacity to their index and penalized bins with a rest capacity much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Calculate ratio of rest capacity to bin index, penalized by large capacity.\\n scores = bins / np.arange(1, len(bins) + 1)\\n scores = scores / (1 + np.maximum(0, bins - item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score of 1 divided by the difference between the maximum capacity and the bin's rest capacity, or 0 if the bin cannot accommodate the item.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n idx = bins>=item\\n scores[idx] = np.minimum(1.0, 1.0/(bins[idx]-item))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the inverse of the remaining capacity, and return the maximum score if the remaining capacity is less than a threshold, else return -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n threshold = bins.max() / 2\\n scores = 1.0 / np.maximum(bins - item, 1)\\n scores[bins < item] = -1\\n scores[bins <= threshold] = np.maximum(scores[bins <= threshold], -1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as the product of the bin's rest capacity and the exponential of the negative bin number, penalized by the number of bins that can fit the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n num_feasible_bins = len(feasible_bins)\\n scores = feasible_bins * np.exp(-np.arange(num_feasible_bins))\\n scores /= np.sum(scores)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of rest capacity and the reciprocal of bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * np.reciprocal(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the rest capacity with the inverse of the bin index, and subtracts the negative maximum rest capacity from the product to adjust the score for the maximum capacity bin and set it to 0 if feasible and -1 if infeasible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculates the scores for each bin based on the item size and remaining bin capacities.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Array of remaining capacities for feasible bins.\\n\\n Returns:\\n Array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of remaining capacity and inverse bin index.\\n scores = bins * (1.0 / np.arange(1, len(bins) + 1))\\n\\n # Adjust scores for maximum capacity bin and infeasible bins.\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n scores[bins < item] = -1\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"An algorithm that calculates the score of a bin as the product of the inverse of bin index, the inverse of bin rest capacity, and the size of the bin.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n # Get valid bins with enough capacity\\n valid_bins = bins[bins >= item]\\n # Ensure no empty bin is used\\n valid_bins = valid_bins[valid_bins != 0]\\n # Calculate the score for each valid bin\\n scores = (1 / np.arange(1, len(valid_bins) + 1)) * (1 / valid_bins) * item\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin as a weighted sum of its rest capacity and its ratio to the item size, where the weights are inversely proportional to the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score of a bin as a weighted sum of its rest capacity and its ratio to the item size, where the weights are inversely proportional to the bin index.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n weights = 1.0 / np.arange(1, len(bins) + 1)\\n scores = weights * bins / item\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm calculates scores based on a weighted average of bin rest capacity, maximum bin capacity, and bin number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates scores for a set of bins to assign an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the maximum bin capacity.\\n max_capacity = np.max(bins)\\n\\n # Calculate the bin number.\\n bin_number = np.arange(len(bins)) + 1\\n\\n # Calculate the scores.\\n scores = 0.5 * rest_capacities / max_capacity + 0.25 * bin_number + 0.25\\n\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Prioritizes bins with slightly smaller rest capacity than item size and penalizes bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins, dtype=np.float32)\\n scores[bins <= item] = -1e9\\n scores[bins == bins.max()] = -1e9\\n scores -= (bins - item)**2\\n return scores\",\n \"objective\": 0.04779,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm that calculates the ratio of the item to the bin capacity and penalizes full bins more harshly using an exponential function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / np.maximum(bins, 1e-8)\\n scores /= np.exp(bins)\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{ New algorithm: Calculate the scores for each bin by subtracting 1 from the rest capacity if it is less than the maximum capacity, subtracting 2 if it is equal to the maximum capacity, and subtracting 3 if the rest capacity is less than the item size. }\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(\\n bins < item,\\n -3,\\n np.where(bins == item, -2, -1 * np.minimum(1, bins - item - 1))\\n )\\n return scores\",\n \"objective\": 0.05131,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score of each bin based on the current fill level, using a weighted average of the fill level and the inverse of the bin number, then score based on the fill level only.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n assert (bins >= item).all(), \\\"Bin capacity should be larger than or equal to the item size\\\"\\n fill_level = 1 - bins / (bins + item)\\n bin_number = np.arange(1, len(bins) + 1)\\n scores = 0.5 * fill_level + 0.5 / bin_number\\n scores[bins == item] = -np.inf # Exclude full bins\\n return scores\",\n \"objective\": 0.05343,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm initializes scores for bins that have enough capacity as 1, and 0 otherwise, and then penalizes bins with a full capacity by decreasing their scores by 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones(len(bins))\\n scores[bins < item] = 0\\n scores[bins == item] -= 0.5\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the ratio of the item size to the bin's rest capacity, penalized by the number of bins that can fit the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n if len(bins) == 0:\\n return np.array([[-1.]])\\n ratios = item / bins\\n penalty = 1 / (np.sum(ratios < 1) + 1)\\n scores = penalty * ratios\\n scores[np.argmax(scores)] = 0.\\n return scores\",\n \"objective\": 0.05654,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacities = bins - item\\n scores = rest_capacities * np.exp(rest_capacities * np.arange(len(bins))) * (1 / np.abs(rest_capacities)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(bins, np.exp(np.multiply(rest_capacities, np.arange(1, len(rest_capacities) + 1)))) / np.abs(rest_capacities)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the existing algorithm include: inverse function, exponent, and bin size square. The new algorithm uses the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cube of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the cube of the bin's size.\\n cube_size = np.power(bins, 3)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_cap_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A comprehensive score that combines the geometric mean of the bin's size and rest capacity, the exponential of the product of the bin's index and rest capacity, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item to.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are\\n larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n size_rest_capacity_gm = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n index_rest_capacity_exp = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the inverse of the absolute difference between the item size and the\\n # bin's rest capacity.\\n item_rest_capacity_diff_inv = 1 / np.abs(bins - item)\\n\\n # Combine the three scores into a comprehensive score.\\n scores = size_rest_capacity_gm * index_rest_capacity_exp * item_rest_capacity_diff_inv\\n\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, and the square root of the bin's size}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.abs(bins - item) + np.exp(bins * np.arange(len(bins)) - 0.5 * item) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp = np.exp(np.multiply(bins, np.arange(len(bins))))\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(np.multiply(bins, exp), 1 / diff)\\n\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.multiply(1.0 / np.abs(item - bins), np.sqrt(bins)) * np.exp(bins * np.arange(bins.shape[0]))\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity, and the bin index.\",\n \"code\": \"def score(item, bins):\\n scores = bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins - item) + 1) * np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacities = bins - item\\n scores = rest_capacities * np.exp(rest_capacities * np.arange(len(bins))) * (1 / np.abs(rest_capacities)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((bins - item / 2) * np.arange(1, len(bins) + 1)) / np.sqrt(np.abs(item - bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(bins, np.exp(np.multiply(rest_capacities, np.arange(1, len(rest_capacities) + 1)))) / np.abs(rest_capacities)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the existing algorithm include: inverse function, exponent, and bin size square. The new algorithm uses the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cube of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the cube of the bin's size.\\n cube_size = np.power(bins, 3)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_cap_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A comprehensive score that combines the geometric mean of the bin's size and rest capacity, the exponential of the product of the bin's index and rest capacity, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item to.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are\\n larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n size_rest_capacity_gm = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n index_rest_capacity_exp = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the inverse of the absolute difference between the item size and the\\n # bin's rest capacity.\\n item_rest_capacity_diff_inv = 1 / np.abs(bins - item)\\n\\n # Combine the three scores into a comprehensive score.\\n scores = size_rest_capacity_gm * index_rest_capacity_exp * item_rest_capacity_diff_inv\\n\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, and the square root of the bin's size}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.abs(bins - item) + np.exp(bins * np.arange(len(bins)) - 0.5 * item) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity and its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp = np.exp(np.multiply(bins, np.arange(len(bins))))\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(np.multiply(bins, exp), 1 / diff)\\n\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_bin_rest_index = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_prod_bin_rest_index = np.exp(prod_bin_rest_index)\\n\\n # Calculate the square of the bin's size.\\n bin_size_squared = np.square(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_prod_bin_rest_index * bin_size_squared\\n\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the linear of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the linear of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the linear of the bin's size.\\n linear_size = bins\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * exp_cap_idx * linear_size\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea is to combine the different operations, including exponential, square root, and division, in various ways to calculate the bin scores. Inspired by this idea, the new algorithm calculates the score as the sum of the exponential of the product of the bin's rest capacity and its index, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * np.arange(1, len(bins) + 1)) + np.sqrt(bins) + 1 / np.abs(bins - item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacities = bins - item\\n scores = rest_capacities * np.exp(rest_capacities * np.arange(len(bins))) * (1 / np.abs(rest_capacities)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((bins - item / 2) * np.arange(1, len(bins) + 1)) / np.sqrt(np.abs(item - bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates a score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n\\n # Calculate the rest capacity of each bin.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = np.multiply(bins, np.exp(np.multiply(rest_capacities, np.arange(1, len(rest_capacities) + 1)))) / np.abs(rest_capacities)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the existing algorithm include: inverse function, exponent, and bin size square. The new algorithm uses the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cube of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the cube of the bin's size.\\n cube_size = np.power(bins, 3)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_cap_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A comprehensive score that combines the geometric mean of the bin's size and rest capacity, the exponential of the product of the bin's index and rest capacity, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Scores a set of bins to assign an item to.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are\\n larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n size_rest_capacity_gm = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n index_rest_capacity_exp = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the inverse of the absolute difference between the item size and the\\n # bin's rest capacity.\\n item_rest_capacity_diff_inv = 1 / np.abs(bins - item)\\n\\n # Combine the three scores into a comprehensive score.\\n scores = size_rest_capacity_gm * index_rest_capacity_exp * item_rest_capacity_diff_inv\\n\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{Algorithm: Calculate the score for each bin based on the sum of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, and the square root of the bin's size}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1.0 / np.abs(bins - item) + np.exp(bins * np.arange(len(bins)) - 0.5 * item) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the division of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(len(bins))) / np.abs(bins - item))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea is to comprehensively consider the bin's size, rest capacity, and its difference from the item size. My new algorithm calculates the score for each bin by multiplying the inverse of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's index and its size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = np.abs(bins - item)\\n inv_diff = 1 / diff\\n sq_rest = bins ** 2\\n exp_idx_size = np.exp(bins * np.arange(len(bins)))\\n scores = inv_diff * sq_rest * exp_idx_size\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the difference between the item size and the bin's rest capacity, the arithmetic mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score a set of bins to assign an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the item size and the bin's rest capacity.\\n diff = bins - item\\n\\n # Calculate the inverse of the difference.\\n inv_diff = 1.0 / diff\\n\\n # Calculate the arithmetic mean of the bin's size and rest capacity.\\n mean = (bins + item) / 2.0\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp = np.exp(np.arange(len(bins)) * bins)\\n\\n # Calculate the score.\\n scores = inv_diff * mean * exp\\n\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size divided by the square of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the absolute difference between the item and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size divided by the square of the bin's index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product.\\n exp_prod = np.exp(prod)\\n\\n # Calculate the square of the bin's size.\\n size_sq = bins**2\\n\\n # Calculate the square of the bin's index.\\n index_sq = np.arange(1, len(bins) + 1)**2\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_prod * (size_sq / index_sq)\\n\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity to the power of its index, the exponential of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score for each bin based on the product of the bin's rest capacity to the power of its index, the exponential of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = np.power(bins, np.arange(len(bins))) * np.exp(bins) * (1 / np.abs(bins - item))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacities = bins - item\\n scores = rest_capacities * np.exp(rest_capacities * np.arange(len(bins))) * (1 / np.abs(rest_capacities)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((bins - item / 2) * np.arange(1, len(bins) + 1)) / np.sqrt(np.abs(item - bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus the item size, and the inverse of the square of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins * np.exp((bins - item) * np.arange(1, len(bins) + 1))) / np.square(np.abs(bins - item)))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the square root of the inverse of the absolute difference between the item size and the bin's rest capacity, the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n bin_size = bins - item\\n bin_idx = np.arange(len(bins))\\n scores = np.sqrt(1 / np.abs(bin_size)) * bins * np.exp(bin_size * bin_idx - item / 2)\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the existing algorithm include: inverse function, exponent, and bin size square. The new algorithm uses the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cube of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the cube of the bin's size.\\n cube_size = np.power(bins, 3)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_cap_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the inverse function of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"def score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score for each bin based on the multiplication of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n bin_sizes = bins - item\\n scores = bin_sizes * np.exp(bins * np.arange(1, len(bins) + 1, 1)) / abs(bin_sizes)\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the provided algorithm: item size, bin rest capacity, bin index. New algorithm: Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, divided by the sum of the exponentials of the products of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * np.arange(len(bins)) - 0.5 * item) / np.sqrt(np.abs(bins - item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the division of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(len(bins))) / np.abs(bins - item))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea is to comprehensively consider the bin's size, rest capacity, and its difference from the item size. My new algorithm calculates the score for each bin by multiplying the inverse of the absolute difference between the item size and the bin's rest capacity, the square of the bin's rest capacity, and the exponential of the product of the bin's index and its size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = np.abs(bins - item)\\n inv_diff = 1 / diff\\n sq_rest = bins ** 2\\n exp_idx_size = np.exp(bins * np.arange(len(bins)))\\n scores = inv_diff * sq_rest * exp_idx_size\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity to the power of its index, the exponential of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score for each bin based on the product of the bin's rest capacity to the power of its index, the exponential of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = np.power(bins, np.arange(len(bins))) * np.exp(bins) * (1 / np.abs(bins - item))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacities = bins - item\\n scores = rest_capacities * np.exp(rest_capacities * np.arange(len(bins))) * (1 / np.abs(rest_capacities)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((bins - item / 2) * np.arange(1, len(bins) + 1)) / np.sqrt(np.abs(item - bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus the item size, and the inverse of the square of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins * np.exp((bins - item) * np.arange(1, len(bins) + 1))) / np.square(np.abs(bins - item)))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the square root of the inverse of the absolute difference between the item size and the bin's rest capacity, the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n bin_size = bins - item\\n bin_idx = np.arange(len(bins))\\n scores = np.sqrt(1 / np.abs(bin_size)) * bins * np.exp(bin_size * bin_idx - item / 2)\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the existing algorithm include: inverse function, exponent, and bin size square. The new algorithm uses the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cube of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the cube of the bin's size.\\n cube_size = np.power(bins, 3)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_cap_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the inverse function of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"def score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score for each bin based on the multiplication of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n bin_sizes = bins - item\\n scores = bin_sizes * np.exp(bins * np.arange(1, len(bins) + 1, 1)) / abs(bin_sizes)\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of a scaling factor, the bin's index, and rest capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, \\n the geometric mean of the bin's size and rest capacity, and the exponential of the product of a scaling factor, the bin's index, and rest capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1.0 / abs_diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geo_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of a scaling factor, the bin's index, and rest capacity.\\n exp_prod = np.exp(0.1 * np.arange(len(bins)) * bins)\\n\\n # Calculate the bin score.\\n scores = inv_diff * geo_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the provided algorithm: item size, bin rest capacity, bin index. New algorithm: Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, divided by the sum of the exponentials of the products of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * np.arange(len(bins)) - 0.5 * item) / np.sqrt(np.abs(bins - item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the division of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(len(bins))) / np.abs(bins - item))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"{New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index, and the inverse of the absolute difference between the item size and the bin's rest capacity.}\",\n \"code\": \"import numpy as np\\n\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the\\n bin's size, the exponential of the product of the bin's rest\\n capacity with its index, and the inverse of the absolute\\n difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins,\\n which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n max_bin = np.max(bins)\\n min_bin = np.min(bins)\\n avg_bin = np.mean(bins)\\n scores = bins * np.exp(bins * np.arange(len(bins))) / np.abs(item - bins)\\n\\n # Penalize bins that are too full or too empty\\n scores = scores * (1 - np.abs(bins - avg_bin) / (max_bin - min_bin))\\n\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity to the power of its index, the exponential of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score for each bin based on the product of the bin's rest capacity to the power of its index, the exponential of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n scores = np.power(bins, np.arange(len(bins))) * np.exp(bins) * (1 / np.abs(bins - item))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, the inverse of the absolute difference between the item size and the bin's rest capacity, and the square root of the bin's size.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n rest_capacities = bins - item\\n scores = rest_capacities * np.exp(rest_capacities * np.arange(len(bins))) * (1 / np.abs(rest_capacities)) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculates the score for each bin based on the given item size.\\n\\n The score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of the bin's index and rest capacity.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geom_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of the bin's index and rest capacity.\\n exp_prod = np.exp(np.arange(len(bins)) * (bins - item))\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * geom_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp((bins - item / 2) * np.arange(1, len(bins) + 1)) / np.sqrt(np.abs(item - bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus half of the item size, and the inverse of the absolute difference between the item size and the bin's rest capacity.\\n scores = bins * np.exp((bins - item / 2) * np.arange(len(bins))) / np.abs(bins - item)\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_indicator = np.maximum(np.zeros(bins.size), bins - item)\\n scores = 1 / np.abs(rest_indicator) * np.sqrt(bins) * np.exp(rest_indicator * np.arange(bins.size) - item * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score of each bin by multiplying the exponential of the difference between the item's size and the bin's rest capacity with the square root of the exponential of the product of the bin's rest capacity and its index, and the exponential of the sum of the inverse of the absolute difference between the item's size and the bin's rest capacity and the square root of the bin's size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = np.exp(-np.abs(rest_capacities)) * np.sqrt(np.exp(rest_capacities * np.arange(1, len(bins) + 1))) * np.exp(1 / np.abs(rest_capacities) + np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the bin's size, the exponential of the product of the bin's rest capacity with its index minus the item size, and the inverse of the square of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins * np.exp((bins - item) * np.arange(1, len(bins) + 1))) / np.square(np.abs(bins - item)))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size, the square root of the bin's size, and the inverse of the absolute difference between the item size and the bin's rest capacity\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * (np.arange(1, bins.size+1) - item/2)) * np.sqrt(bins) * 1/np.abs(bins - item)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the square root of the inverse of the absolute difference between the item size and the bin's rest capacity, the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n bin_size = bins - item\\n bin_idx = np.arange(len(bins))\\n scores = np.sqrt(1 / np.abs(bin_size)) * bins * np.exp(bin_size * bin_idx - item / 2)\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the existing algorithm include: inverse function, exponent, and bin size square. The new algorithm uses the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cube of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for assigning an item to a set of bins.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1 / diff\\n\\n # Calculate the product of the bin's rest capacity and its index.\\n prod_cap_idx = bins * np.arange(1, len(bins) + 1)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index.\\n exp_cap_idx = np.exp(prod_cap_idx)\\n\\n # Calculate the cube of the bin's size.\\n cube_size = np.power(bins, 3)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff * exp_cap_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the inverse function of the absolute difference between the item size and the bin's rest capacity.\",\n \"code\": \"def score(item: int, bins: np.array) -> np.array:\\n \\\"\\\"\\\"Calculate the score for each bin based on the multiplication of the product of the bin's size and the exponential of the product of the bin's rest capacity with its index by the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n bin_sizes = bins - item\\n scores = bin_sizes * np.exp(bins * np.arange(1, len(bins) + 1, 1)) / abs(bin_sizes)\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the geometric mean of the bin's size and rest capacity, and the exponential of the product of a scaling factor, the bin's index, and rest capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n The bin score is the product of the inverse of the absolute difference between the item size and the bin's rest capacity, \\n the geometric mean of the bin's size and rest capacity, and the exponential of the product of a scaling factor, the bin's index, and rest capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_diff = 1.0 / abs_diff\\n\\n # Calculate the geometric mean of the bin's size and rest capacity.\\n geo_mean = np.sqrt(bins * (bins - item))\\n\\n # Calculate the exponential of the product of a scaling factor, the bin's index, and rest capacity.\\n exp_prod = np.exp(0.1 * np.arange(len(bins)) * bins)\\n\\n # Calculate the bin score.\\n scores = inv_diff * geo_mean * exp_prod\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the multiplication of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the product of the bin's size and the bin's rest capacity, and the exponential of the product of the bin's index with the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = (1 / np.abs(bins - item)) * np.sqrt(bins * (bins - item)) * np.exp(bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The backbone idea in the provided algorithms is to calculate the score for each bin based on the product or multiplication of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity. A new algorithm that has a totally different form can be designed by using the sum or addition of the functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the sum of functions of the bin's rest capacity and its index and the inverse function of the absolute difference between the item size and the bin's rest capacity.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse function of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the sum of the functions of the bin's rest capacity and its index and the inverse function of the absolute difference.\\n scores = bins + np.arange(len(bins)) + inv_abs_diff\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the square of the bin's size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / diff**2\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_cap_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the square of the bin's size\\n bin_size_sq = bins**2\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_cap_idx * bin_size_sq\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Main parameters of the provided algorithm: item size, bin rest capacity, bin index. New algorithm: Assign the item to the bin with the maximum score calculated based on the sum of the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size and the inverse of the square root of the absolute difference between the item size and the bin's rest capacity, divided by the sum of the exponentials of the products of the bin's rest capacity with the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins * np.arange(len(bins)) - 0.5 * item) / np.sqrt(np.abs(bins - item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score each bin based on the product of the bin's rest capacity, the exponential of the product of the bin's size and its index, and the inverse of the absolute difference between the item size and the bin's capacity, divided by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins * np.arange(1, len(bins) + 1)) * (1 / np.abs(bins / item - 1))) / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher rest capacity and penalizes bins with rest capacity much larger than item size and equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n\\n # Find feasible bins that can hold the 'item'.\\n feasible_bins = bins[bins >= item]\\n \\n if len(feasible_bins) == 0:\\n return np.zeros_like(bins)\\n \\n # Calculate the rest capacity after assigning the 'item'.\\n rest_capacities = feasible_bins - item\\n \\n # Calculate the score for each feasible bin.\\n scores = 1 / (rest_capacities + 1)\\n \\n # Penalize bins with rest capacity much larger than item size or equal to the maximum capacity.\\n max_capacity = np.max(bins)\\n scores -= (rest_capacities > max_capacity - item) * 0.5\\n scores -= (rest_capacities > item) * 0.25\\n \\n # Normalize the scores.\\n scores /= np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Assigns each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = 1 / (rest_capacities * np.arange(1, len(bins) + 1))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\\n\\n Args:\\n item (int): The size of current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of bin available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of square root of bin index.\\n inv_sqrt_idx = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = inv_cap * inv_sqrt_idx * bins\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified version that calculates the ratio of the item to the bin capacity and penalizes full bins more harshly using a logarithmic function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 - np.power(1 - item / bins, 2)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will prioritize bins with specific patterns in their rest capacities. The patterns are repeated but alternated by bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their rest capacities and item size.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins.\\n\\n Returns:\\n np.array: Scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Pattern 1: Prioritize bins with rest capacity equal to item size\\n pattern1 = np.where(bins == item, np.full(bins.shape, 100), np.zeros(bins.shape))\\n\\n # Pattern 2: Prioritize bins with alternating rest capacities\\n pattern2 = np.where(bins % (item * 2) == item, np.full(bins.shape, 50), np.zeros(bins.shape))\\n\\n # Combine patterns\\n scores = pattern1 + pattern2\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A score function that prioritized bins based on the ratio of their rest capacity to their index and penalized bins with a rest capacity much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Calculate ratio of rest capacity to bin index, penalized by large capacity.\\n scores = bins / np.arange(1, len(bins) + 1)\\n scores = scores / (1 + np.maximum(0, bins - item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score of 1 divided by the difference between the maximum capacity and the bin's rest capacity, or 0 if the bin cannot accommodate the item.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n idx = bins>=item\\n scores[idx] = np.minimum(1.0, 1.0/(bins[idx]-item))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the inverse of the remaining capacity, and return the maximum score if the remaining capacity is less than a threshold, else return -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n threshold = bins.max() / 2\\n scores = 1.0 / np.maximum(bins - item, 1)\\n scores[bins < item] = -1\\n scores[bins <= threshold] = np.maximum(scores[bins <= threshold], -1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of a bin as the sum of the inverse of bin index multiplied by the size of the bin and the inverse of bin rest capacity multiplied by the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n bin_idx = np.argwhere(bins >= item).flatten()\\n bin_idx_weight = 1 / (1 + bin_idx)\\n bin_cap_weight = 1 / (1 + bins[bin_idx] - item)\\n scores = bin_idx_weight * bin_cap_weight\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as the product of the bin's rest capacity and the exponential of the negative bin number, penalized by the number of bins that can fit the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n num_feasible_bins = len(feasible_bins)\\n scores = feasible_bins * np.exp(-np.arange(num_feasible_bins))\\n scores /= np.sum(scores)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of rest capacity and the reciprocal of bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * np.reciprocal(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, bin index, and a small constant to avoid division by zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, bin index, and a small constant to avoid division by zero.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Avoid division by zero by adding a small constant to the denominator.\\n constant = 1e-6\\n\\n # Calculate the weighted sum of rest capacity, bin index, and constant.\\n denominators = bins + bins * np.log(np.arange(1, len(bins) + 1)) + constant\\n\\n # Calculate the scores.\\n scores = item / denominators\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the rest capacity with the inverse of the bin index, and subtracts the negative maximum rest capacity from the product to adjust the score for the maximum capacity bin and set it to 0 if feasible and -1 if infeasible.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Calculates the scores for each bin based on the item size and remaining bin capacities.\\n\\n Args:\\n item: Size of the item to be assigned.\\n bins: Array of remaining capacities for feasible bins.\\n\\n Returns:\\n Array of scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Calculate the product of remaining capacity and inverse bin index.\\n scores = bins * (1.0 / np.arange(1, len(bins) + 1))\\n\\n # Adjust scores for maximum capacity bin and infeasible bins.\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n scores[bins < item] = -1\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of bin index, and the size of the bin.\",\n \"code\": \"def score(item, bins):\\n scores = np.zeros(len(bins))\\n available_bins = np.where(bins >= item)[0]\\n if len(available_bins) > 0:\\n scores[available_bins] = 1 / bins[available_bins] * 1 / np.arange(1, len(available_bins) + 1) * item\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified Algorithm: Prioritize bins with rest capacities equal to item size and small alternating differences from the item size to minimize bin usage, using a combination of score functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Modified Algorithm: Prioritize bins with rest capacities equal to item size and small alternating differences from the item size to minimize bin usage, using a combination of score functions.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute differences between the item size and the bin capacities.\\n abs_diffs = np.abs(bins - item)\\n\\n # Calculate the alternating differences between the item size and the bin capacities.\\n alt_diffs = abs_diffs % 2\\n\\n # Calculate the scores for the bins.\\n scores = 1 / (abs_diffs + 1) * (1 - alt_diffs)\\n\\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of a bin as a weighted sum of its rest capacity and its ratio to the item size, where the weights are inversely proportional to the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score of a bin as a weighted sum of its rest capacity and its ratio to the item size, where the weights are inversely proportional to the bin index.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n weights = 1.0 / np.arange(1, len(bins) + 1)\\n scores = weights * bins / item\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's rest capacity and the sum of the inverse of the bin number and a small constant to avoid division by zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score for each bin as the product of the bin's rest capacity and the sum of the inverse of the bin number and a small constant to avoid division by zero.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the bin numbers.\\n inv_bin_nums = 1.0 / np.arange(1, bins.shape[0] + 1)\\n\\n # Calculate the scores.\\n scores = bins * (inv_bin_nums + 0.0001)\\n\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher rest capacity and penalizes bins with rest capacity much larger than item size and equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n\\n # Find feasible bins that can hold the 'item'.\\n feasible_bins = bins[bins >= item]\\n \\n if len(feasible_bins) == 0:\\n return np.zeros_like(bins)\\n \\n # Calculate the rest capacity after assigning the 'item'.\\n rest_capacities = feasible_bins - item\\n \\n # Calculate the score for each feasible bin.\\n scores = 1 / (rest_capacities + 1)\\n \\n # Penalize bins with rest capacity much larger than item size or equal to the maximum capacity.\\n max_capacity = np.max(bins)\\n scores -= (rest_capacities > max_capacity - item) * 0.5\\n scores -= (rest_capacities > item) * 0.25\\n \\n # Normalize the scores.\\n scores /= np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Assigns each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = 1 / (rest_capacities * np.arange(1, len(bins) + 1))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\\n\\n Args:\\n item (int): The size of current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of bin available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of square root of bin index.\\n inv_sqrt_idx = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = inv_cap * inv_sqrt_idx * bins\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score of a bin is calculated as the product of the inverse of bin index, the inverse of bin available capacity after assigning the item, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score of a set of bins for assigning an item.\\n\\n The score of a bin is calculated as the product of the inverse of bin index, the inverse of bin available capacity after assigning the item, and the size of the bin.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of bin index and available capacity\\n inv_index = 1.0 / np.arange(1, len(bins) + 1)\\n inv_capacity = 1.0 / (bins - item)\\n\\n # Calculate the scores\\n scores = inv_index * inv_capacity * bins\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed scoring function calculates the score of each bin as the reciprocal of the sum of its rest capacity and the ratio of the item's size to the bin's rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins + item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, square root of bin index, and a small constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.sqrt(np.arange(1, bins.shape[0]+1)) + 1e-6))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A score function that prioritized bins based on the ratio of their rest capacity to their index and penalized bins with a rest capacity much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Calculate ratio of rest capacity to bin index, penalized by large capacity.\\n scores = bins / np.arange(1, len(bins) + 1)\\n scores = scores / (1 + np.maximum(0, bins - item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score of 1 divided by the difference between the maximum capacity and the bin's rest capacity, or 0 if the bin cannot accommodate the item.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n idx = bins>=item\\n scores[idx] = np.minimum(1.0, 1.0/(bins[idx]-item))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score of bin i is calculated as the product of the inverse of the difference between the bin's rest capacity and the item size, and the exponential of the negative bin number, divided by the number of feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n This function calculates the score for each bin in 'bins' for assigning an item of size 'item'.\\n The score is calculated as the product of the inverse of the difference between the bin's rest capacity and the item size, and the exponential of the negative bin number, divided by the number of feasible bins.\\n The input 'bins' is a Numpy array of integers representing the rest capacities of the bins.\\n The output 'scores' is a Numpy array of floats representing the scores for each bin.\\n\\n Args:\\n item (int): The size of the item to be assigned.\\n bins (np.ndarray): A Numpy array of integers representing the rest capacities of the bins.\\n\\n Returns:\\n np.ndarray: A Numpy array of floats representing the scores for each bin.\\n \\\"\\\"\\\"\\n # Calculate the difference between the bin's rest capacity and the item size\\n diff = bins - item\\n\\n # Calculate the inverse of the difference\\n inv_diff = 1 / diff\\n\\n # Calculate the exponential of the negative bin number\\n exp_neg_bin_num = np.exp(-np.arange(len(bins)))\\n\\n # Calculate the score for each bin\\n scores = inv_diff * exp_neg_bin_num / len(bins)\\n\\n # Return the scores\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the inverse of the remaining capacity, and return the maximum score if the remaining capacity is less than a threshold, else return -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n threshold = bins.max() / 2\\n scores = 1.0 / np.maximum(bins - item, 1)\\n scores[bins < item] = -1\\n scores[bins <= threshold] = np.maximum(scores[bins <= threshold], -1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of a bin as the sum of the inverse of bin index multiplied by the size of the bin and the inverse of bin rest capacity multiplied by the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n bin_idx = np.argwhere(bins >= item).flatten()\\n bin_idx_weight = 1 / (1 + bin_idx)\\n bin_cap_weight = 1 / (1 + bins[bin_idx] - item)\\n scores = bin_idx_weight * bin_cap_weight\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A scoring function that calculates the score of a bin as the quotient of the sum of bin size and bin available capacity divided by the sum of bin index and bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[(bins >= item)]\\n if len(feasible_bins):\\n scores = np.array([(feasible_bins[i] + item) / (i + feasible_bins[i]) for i in range(len(feasible_bins))])\\n else:\\n scores = np.array([])\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign each bin a score that is inversely proportional to the ratio of the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = np.where(bins >= item)[0]\\n scores[valid_bins] = 1 / (bins[valid_bins] / item)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avail = np.array([max(b - item, 0) for b in bins])\\n pos = np.arange(len(avail), dtype=np.int32)\\n scores = np.reciprocal(np.maximum(avail, 1)) * pos\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin as the product of the bin's rest capacity and the exponential of the negative bin number, penalized by the number of bins that can fit the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[bins >= item]\\n num_feasible_bins = len(feasible_bins)\\n scores = feasible_bins * np.exp(-np.arange(num_feasible_bins))\\n scores /= np.sum(scores)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the product of rest capacity and the reciprocal of bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * np.reciprocal(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, bin index, and a small constant to avoid division by zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, bin index, and a small constant to avoid division by zero.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Avoid division by zero by adding a small constant to the denominator.\\n constant = 1e-6\\n\\n # Calculate the weighted sum of rest capacity, bin index, and constant.\\n denominators = bins + bins * np.log(np.arange(1, len(bins) + 1)) + constant\\n\\n # Calculate the scores.\\n scores = item / denominators\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher rest capacity and penalizes bins with rest capacity much larger than item size and equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n\\n # Find feasible bins that can hold the 'item'.\\n feasible_bins = bins[bins >= item]\\n \\n if len(feasible_bins) == 0:\\n return np.zeros_like(bins)\\n \\n # Calculate the rest capacity after assigning the 'item'.\\n rest_capacities = feasible_bins - item\\n \\n # Calculate the score for each feasible bin.\\n scores = 1 / (rest_capacities + 1)\\n \\n # Penalize bins with rest capacity much larger than item size or equal to the maximum capacity.\\n max_capacity = np.max(bins)\\n scores -= (rest_capacities > max_capacity - item) * 0.5\\n scores -= (rest_capacities > item) * 0.25\\n \\n # Normalize the scores.\\n scores /= np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Assigns each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = 1 / (rest_capacities * np.arange(1, len(bins) + 1))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\\n\\n Args:\\n item (int): The size of current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of bin available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of square root of bin index.\\n inv_sqrt_idx = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = inv_cap * inv_sqrt_idx * bins\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of bin available capacity\\n inv_cap = 1.0 / np.maximum(bins - item, 1e-9)\\n\\n # Calculate the inverse of bin index\\n inv_idx = 1.0 / np.arange(1, len(bins) + 1)\\n\\n # Calculate the score of each bin\\n scores = inv_cap * inv_idx * bins\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is a weighted sum of the inverse of the product of the bin's rest capacity and its index, and the inverse of the difference between the bin's size and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the following formula:\\n\\n score = w1 * (1 / (bin_rest_capacity * bin_index)) + w2 * (1 / (bin_size - item_size))\\n\\n Where:\\n\\n * bin_rest_capacity is the remaining capacity in the bin\\n * bin_index is the index of the bin\\n * bin_size is the size of the bin\\n * item_size is the size of the item being assigned\\n * w1 and w2 are weights that can be adjusted to prioritize different factors\\n\\n The bin with the highest score is selected for the item.\\n\\n Args:\\n item (int): The size of the item being assigned.\\n bins (np.array): A numpy array of the remaining capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Define the weights\\n w1 = 0.5\\n w2 = 0.5\\n\\n # Calculate the score for each bin\\n scores = w1 * (1 / (bins * np.arange(1, len(bins) + 1))) + w2 * (1 / (bins - item))\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores (np.array): The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the remaining capacity of each bin and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin based on its remaining capacity and difference to the item size.\\n scores = diff * (bins / diff)\\n\\n # Favor bins with lower remaining capacity.\\n scores /= bins\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Compute the inverse of sum of the inverse of the difference of the item size and the remaining capacity and the inverse of the remaining capacity.}\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (1.0 / (item - bins) + 1.0 / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, square root of bin index, and a small constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.sqrt(np.arange(1, bins.shape[0]+1)) + 1e-6))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A score function that prioritized bins based on the ratio of their rest capacity to their index and penalized bins with a rest capacity much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Calculate ratio of rest capacity to bin index, penalized by large capacity.\\n scores = bins / np.arange(1, len(bins) + 1)\\n scores = scores / (1 + np.maximum(0, bins - item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score of 1 divided by the difference between the maximum capacity and the bin's rest capacity, or 0 if the bin cannot accommodate the item.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n idx = bins>=item\\n scores[idx] = np.minimum(1.0, 1.0/(bins[idx]-item))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the normalized product of the inverse of the difference between the bin's rest capacity and the item size, and the exponential of the negative bin number, divided by the number of feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n eps = 1e-10\\n feasible_idx = bins >= item\\n feasible_bins = bins[feasible_idx]\\n num_feasible_bins = len(feasible_bins)\\n scores = np.zeros(len(bins))\\n if num_feasible_bins > 0:\\n scores[feasible_idx] = (feasible_bins - item + eps) ** (-1) * np.exp(-len(bins) + np.arange(num_feasible_bins)) / num_feasible_bins\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the inverse of the remaining capacity, and return the maximum score if the remaining capacity is less than a threshold, else return -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n threshold = bins.max() / 2\\n scores = 1.0 / np.maximum(bins - item, 1)\\n scores[bins < item] = -1\\n scores[bins <= threshold] = np.maximum(scores[bins <= threshold], -1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of a bin as the sum of the inverse of bin index multiplied by the size of the bin and the inverse of bin rest capacity multiplied by the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n bin_idx = np.argwhere(bins >= item).flatten()\\n bin_idx_weight = 1 / (1 + bin_idx)\\n bin_cap_weight = 1 / (1 + bins[bin_idx] - item)\\n scores = bin_idx_weight * bin_cap_weight\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The revised scoring function considers the sum of the inverse square of the bin index and inverse of the available capacity, multiplied by the square root of the bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Revised scoring function.\\n\\n Args:\\n item (int): Size of current item.\\n bins (np.array): Rest capacities of feasible bins, larger than the item size.\\n\\n Returns:\\n np.array: Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n bin_index = np.arange(len(bins)) + 1\\n available_capacity = np.maximum(bins - item, 0)\\n bin_size = np.where(available_capacity > 0, bins, np.inf)\\n scores = (1 / bin_index**2 + 1 / available_capacity) * np.sqrt(bin_size)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A scoring function that calculates the score of a bin as the quotient of the sum of bin size and bin available capacity divided by the sum of bin index and bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n feasible_bins = bins[(bins >= item)]\\n if len(feasible_bins):\\n scores = np.array([(feasible_bins[i] + item) / (i + feasible_bins[i]) for i in range(len(feasible_bins))])\\n else:\\n scores = np.array([])\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Assign each bin a score that is inversely proportional to the ratio of the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = np.where(bins >= item)[0]\\n scores[valid_bins] = 1 / (bins[valid_bins] / item)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a score function that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes a score for each bin that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array containing the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array containing the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the rest capacity ratio for each bin.\\n ratio = bins / item\\n\\n # Compute the score for each bin.\\n scores = ratio / (np.arange(len(bins)) + 1)\\n\\n # Penalize bins with a low rest capacity ratio.\\n scores[ratio < 1.5] /= ratio[ratio < 1.5]\\n\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher rest capacity and penalizes bins with rest capacity much larger than item size and equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n\\n # Find feasible bins that can hold the 'item'.\\n feasible_bins = bins[bins >= item]\\n \\n if len(feasible_bins) == 0:\\n return np.zeros_like(bins)\\n \\n # Calculate the rest capacity after assigning the 'item'.\\n rest_capacities = feasible_bins - item\\n \\n # Calculate the score for each feasible bin.\\n scores = 1 / (rest_capacities + 1)\\n \\n # Penalize bins with rest capacity much larger than item size or equal to the maximum capacity.\\n max_capacity = np.max(bins)\\n scores -= (rest_capacities > max_capacity - item) * 0.5\\n scores -= (rest_capacities > item) * 0.25\\n \\n # Normalize the scores.\\n scores /= np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign each bin a score that is a weighted sum of the inverse of the product of the bin's rest capacity and its index, and the inverse of the square of the difference between the bin's size and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score each bin based on its rest capacity and size difference with the item.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array of the rest capacities of feasible bins.\\n\\n Returns:\\n A Numpy array of scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the product of the bin's rest capacity and its index.\\n rest_capacity_index_inv = 1 / (bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the inverse of the square of the difference between the bin's size and the item's size.\\n size_diff_inv_squared = 1 / ((bins - item) ** 2)\\n\\n # Calculate the weighted sum of the two scores.\\n scores = rest_capacity_index_inv + size_diff_inv_squared\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Assigns each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = 1 / (rest_capacities * np.arange(1, len(bins) + 1))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\\n\\n Args:\\n item (int): The size of current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of bin available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of square root of bin index.\\n inv_sqrt_idx = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = inv_cap * inv_sqrt_idx * bins\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the inverse of bin available capacity\\n inv_cap = 1.0 / np.maximum(bins - item, 1e-9)\\n\\n # Calculate the inverse of bin index\\n inv_idx = 1.0 / np.arange(1, len(bins) + 1)\\n\\n # Calculate the score of each bin\\n scores = inv_cap * inv_idx * bins\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is a weighted sum of the inverse of the product of the bin's rest capacity and its index, and the inverse of the difference between the bin's size and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculates the score for each bin based on the following formula:\\n\\n score = w1 * (1 / (bin_rest_capacity * bin_index)) + w2 * (1 / (bin_size - item_size))\\n\\n Where:\\n\\n * bin_rest_capacity is the remaining capacity in the bin\\n * bin_index is the index of the bin\\n * bin_size is the size of the bin\\n * item_size is the size of the item being assigned\\n * w1 and w2 are weights that can be adjusted to prioritize different factors\\n\\n The bin with the highest score is selected for the item.\\n\\n Args:\\n item (int): The size of the item being assigned.\\n bins (np.array): A numpy array of the remaining capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: A numpy array of the scores for each bin.\\n \\\"\\\"\\\"\\n\\n # Define the weights\\n w1 = 0.5\\n w2 = 0.5\\n\\n # Calculate the score for each bin\\n scores = w1 * (1 / (bins * np.arange(1, len(bins) + 1))) + w2 * (1 / (bins - item))\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores (np.array): The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the remaining capacity of each bin and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin based on its remaining capacity and difference to the item size.\\n scores = diff * (bins / diff)\\n\\n # Favor bins with lower remaining capacity.\\n scores /= bins\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Compute the inverse of sum of the inverse of the difference of the item size and the remaining capacity and the inverse of the remaining capacity.}\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (1.0 / (item - bins) + 1.0 / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, square root of bin index, and a small constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.sqrt(np.arange(1, bins.shape[0]+1)) + 1e-6))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A score function that prioritized bins based on the ratio of their rest capacity to their index and penalized bins with a rest capacity much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Calculate ratio of rest capacity to bin index, penalized by large capacity.\\n scores = bins / np.arange(1, len(bins) + 1)\\n scores = scores / (1 + np.maximum(0, bins - item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score of 1 divided by the difference between the maximum capacity and the bin's rest capacity, or 0 if the bin cannot accommodate the item.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n idx = bins>=item\\n scores[idx] = np.minimum(1.0, 1.0/(bins[idx]-item))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Score bins based on the normalized product of the inverse of the difference between the bin's rest capacity and the item size, and the exponential of the negative bin number, divided by the number of feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n eps = 1e-10\\n feasible_idx = bins >= item\\n feasible_bins = bins[feasible_idx]\\n num_feasible_bins = len(feasible_bins)\\n scores = np.zeros(len(bins))\\n if num_feasible_bins > 0:\\n scores[feasible_idx] = (feasible_bins - item + eps) ** (-1) * np.exp(-len(bins) + np.arange(num_feasible_bins)) / num_feasible_bins\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score of each bin as the inverse of the remaining capacity, and return the maximum score if the remaining capacity is less than a threshold, else return -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.array) -> np.array:\\n threshold = bins.max() / 2\\n scores = 1.0 / np.maximum(bins - item, 1)\\n scores[bins < item] = -1\\n scores[bins <= threshold] = np.maximum(scores[bins <= threshold], -1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score of a bin as the sum of the inverse of bin index multiplied by the size of the bin and the inverse of bin rest capacity multiplied by the difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n bin_idx = np.argwhere(bins >= item).flatten()\\n bin_idx_weight = 1 / (1 + bin_idx)\\n bin_cap_weight = 1 / (1 + bins[bin_idx] - item)\\n scores = bin_idx_weight * bin_cap_weight\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Calculate the score for each bin based on the following: the inverse of the square of the difference between the item size and the bin's rest capacity, the exponential of the product of the bin's index and its rest capacity, and the square root of the bin's size.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the following:\\n the inverse of the square of the difference between the item size and the bin's rest capacity,\\n the exponential of the product of the bin's index and its rest capacity,\\n and the square root of the bin's size.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the item size and the bin's rest capacity.\\n diff = item - bins\\n\\n # Calculate the inverse of the square of the difference.\\n inv_diff_sq = 1 / (diff ** 2)\\n\\n # Calculate the exponential of the product of the bin's index and its rest capacity.\\n exp_idx_cap = np.exp(np.arange(len(bins)) * bins)\\n\\n # Calculate the square root of the bin's size.\\n sqrt_size = np.sqrt(bins)\\n\\n # Calculate the score for each bin.\\n scores = inv_diff_sq * exp_idx_cap * sqrt_size\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin score.\\n\\n Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = 1.0 / available_capacity**2 + np.sqrt(available_capacity / item) / np.arange(1.0, len(bins) + 1.0)\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a score function that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes a score for each bin that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array containing the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array containing the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the rest capacity ratio for each bin.\\n ratio = bins / item\\n\\n # Compute the score for each bin.\\n scores = ratio / (np.arange(len(bins)) + 1)\\n\\n # Penalize bins with a low rest capacity ratio.\\n scores[ratio < 1.5] /= ratio[ratio < 1.5]\\n\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher rest capacity and penalizes bins with rest capacity much larger than item size and equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n\\n # Find feasible bins that can hold the 'item'.\\n feasible_bins = bins[bins >= item]\\n \\n if len(feasible_bins) == 0:\\n return np.zeros_like(bins)\\n \\n # Calculate the rest capacity after assigning the 'item'.\\n rest_capacities = feasible_bins - item\\n \\n # Calculate the score for each feasible bin.\\n scores = 1 / (rest_capacities + 1)\\n \\n # Penalize bins with rest capacity much larger than item size or equal to the maximum capacity.\\n max_capacity = np.max(bins)\\n scores -= (rest_capacities > max_capacity - item) * 0.5\\n scores -= (rest_capacities > item) * 0.25\\n \\n # Normalize the scores.\\n scores /= np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Assign each bin a score that is the sum of the inverse of the square of the difference between the bin's size and the item's size, and the inverse of the product of the bin's rest capacity and its index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1 / (bins - item) ** 2 + 1 / (bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Assigns each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = 1 / (rest_capacities * np.arange(1, len(bins) + 1))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\\n\\n Args:\\n item (int): The size of current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of bin available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of square root of bin index.\\n inv_sqrt_idx = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = inv_cap * inv_sqrt_idx * bins\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the following: the inverse of the square of the difference between the item size and the bin's rest capacity, the inverse of the product of the bin's index and its rest capacity, and the square of the bin's size.\",\n \"code\": \"def score(item, bins):\\n # Calculate the score for each bin\\n scores = (1 / ((item - bins) ** 2)) * (1 / (np.arange(1, bins.size + 1) * bins)) * (bins ** 2)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The proposed algorithm calculates the score for each bin based on the inverse of the difference between the bin's rest capacity and the item size, divided by the square root of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Calculate the score for each bin based on the inverse of the difference between the bin's rest capacity and the item size, divided by the square root of the bin's index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the bin's rest capacity and the item size\\n diff = bins - item\\n\\n # Calculate the inverse of the difference\\n inv_diff = 1 / diff\\n\\n # Calculate the square root of the bin's index\\n sqrt_index = np.sqrt(np.arange(1, len(bins) + 1))\\n\\n # Calculate the score\\n scores = inv_diff / sqrt_index\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign each bin a score that is the sum of the inverse of the product of the bin's rest capacity and its index, and the inverse of the difference between the bin's size and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the product of the bin's rest capacity and its index.\\n inv_prod_cap_idx = 1 / (bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the inverse of the difference between the bin's size and the item's size.\\n inv_diff_size = 1 / (bins - item)\\n\\n # Sum the two inverse values to get the score for each bin.\\n scores = inv_prod_cap_idx + inv_diff_size\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores (np.array): The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the remaining capacity of each bin and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin based on its remaining capacity and difference to the item size.\\n scores = diff * (bins / diff)\\n\\n # Favor bins with lower remaining capacity.\\n scores /= bins\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{New algorithm: Compute the inverse of sum of the inverse of the difference of the item size and the remaining capacity and the inverse of the remaining capacity.}\",\n \"code\": \"def score(item, bins):\\n scores = 1.0 / (1.0 / (item - bins) + 1.0 / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A novel score function that calculates the ratio of the item's size to a weighted sum of rest capacity, square root of bin index, and a small constant.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / (bins + np.sqrt(np.arange(1, bins.shape[0]+1)) + 1e-6))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A score function that prioritized bins based on the ratio of their rest capacity to their index and penalized bins with a rest capacity much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score bins for assigning an item to minimize the number of used bins.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment. \\n \\\"\\\"\\\"\\n\\n # Calculate ratio of rest capacity to bin index, penalized by large capacity.\\n scores = bins / np.arange(1, len(bins) + 1)\\n scores = scores / (1 + np.maximum(0, bins - item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score of 1 divided by the difference between the maximum capacity and the bin's rest capacity, or 0 if the bin cannot accommodate the item.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n idx = bins>=item\\n scores[idx] = np.minimum(1.0, 1.0/(bins[idx]-item))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the following: the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the exponential of the product of the bin's rest capacity and its index, and the cubic root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the following:\\n - the inverse of the square of the absolute difference between the item size and the bin's rest capacity\\n - the exponential of the product of the bin's rest capacity and its index\\n - the cubic root of the bin's size\\n\\n Args:\\n item: The size of the current item\\n bins: The rest capacities of feasible bins, which are larger than the item size\\n\\n Returns:\\n scores: The scores for the bins for assignment\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diff = np.abs(item - bins)\\n\\n # Calculate the inverse of the square of the absolute difference\\n inv_diff_sq = 1 / np.square(diff)\\n\\n # Calculate the exponential of the product of the bin's rest capacity and its index\\n exp_rc_idx = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the cubic root of the bin's size\\n cube_size = np.power(bins, 1 / 3)\\n\\n # Calculate the score for each bin\\n scores = inv_diff_sq * exp_rc_idx * cube_size\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin score.\\n\\n Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = 1.0 / available_capacity**2 + np.sqrt(available_capacity / item) / np.arange(1.0, len(bins) + 1.0)\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a score function that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes a score for each bin that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array containing the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array containing the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the rest capacity ratio for each bin.\\n ratio = bins / item\\n\\n # Compute the score for each bin.\\n scores = ratio / (np.arange(len(bins)) + 1)\\n\\n # Penalize bins with a low rest capacity ratio.\\n scores[ratio < 1.5] /= ratio[ratio < 1.5]\\n\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm prioritizes bins with higher rest capacity and penalizes bins with rest capacity much larger than item size and equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n\\n # Find feasible bins that can hold the 'item'.\\n feasible_bins = bins[bins >= item]\\n \\n if len(feasible_bins) == 0:\\n return np.zeros_like(bins)\\n \\n # Calculate the rest capacity after assigning the 'item'.\\n rest_capacities = feasible_bins - item\\n \\n # Calculate the score for each feasible bin.\\n scores = 1 / (rest_capacities + 1)\\n \\n # Penalize bins with rest capacity much larger than item size or equal to the maximum capacity.\\n max_capacity = np.max(bins)\\n scores -= (rest_capacities > max_capacity - item) * 0.5\\n scores -= (rest_capacities > item) * 0.25\\n \\n # Normalize the scores.\\n scores /= np.max(scores)\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Assign each bin a score that is the sum of the inverse of the square of the difference between the bin's size and the item's size, and the inverse of the product of the bin's rest capacity and its index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1 / (bins - item) ** 2 + 1 / (bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Assigns each bin a score that is inversely proportional to the product of the bin's rest capacity and its index.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n np.array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the rest capacity of each bin after assigning the item.\\n rest_capacities = bins - item\\n\\n # Calculate the score for each bin.\\n scores = 1 / (rest_capacities * np.arange(1, len(bins) + 1))\\n\\n # Return the scores.\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of bin available capacity, the inverse of square root of bin index, and the size of the bin.\\n\\n Args:\\n item (int): The size of current item.\\n bins (Numpy array): The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Numpy array: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of bin available capacity.\\n inv_cap = 1 / (bins - item)\\n\\n # Calculate the inverse of square root of bin index.\\n inv_sqrt_idx = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n\\n # Calculate the score of each bin.\\n scores = inv_cap * inv_sqrt_idx * bins\\n\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the following: the inverse of the square of the difference between the item size and the bin's rest capacity, the inverse of the product of the bin's index and its rest capacity, and the square of the bin's size.\",\n \"code\": \"def score(item, bins):\\n # Calculate the score for each bin\\n scores = (1 / ((item - bins) ** 2)) * (1 / (np.arange(1, bins.size + 1) * bins)) * (bins ** 2)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's rest capacity, and the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diffs = np.abs(bins - item)\\n # Calculate the inverse of the square of the absolute difference\\n inv_sq_diffs = 1 / diffs**2\\n # Calculate the square root of the bin's rest capacity\\n sqrt_capacities = np.sqrt(bins)\\n # Calculate the inverse of the bin's index\\n inv_indices = 1 / np.arange(1, bins.size + 1)\\n # Calculate the score for each bin\\n scores = inv_sq_diffs * sqrt_capacities * inv_indices\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index and the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin score for an item.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n available_capacity = np.maximum(bins - item, 0)\\n ratio = np.maximum(available_capacity / item, 1)\\n scores = (1 / available_capacity**2 + np.sqrt(ratio)) / np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign each bin a score that is the sum of the inverse of the product of the bin's rest capacity and its index, and the inverse of the difference between the bin's size and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the product of the bin's rest capacity and its index.\\n inv_prod_cap_idx = 1 / (bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the inverse of the difference between the bin's size and the item's size.\\n inv_diff_size = 1 / (bins - item)\\n\\n # Sum the two inverse values to get the score for each bin.\\n scores = inv_prod_cap_idx + inv_diff_size\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores (np.array): The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the remaining capacity of each bin and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin based on its remaining capacity and difference to the item size.\\n scores = diff * (bins / diff)\\n\\n # Favor bins with lower remaining capacity.\\n scores /= bins\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign each bin a score that is the sum of the inverse of the product of the bin's rest capacity and its index, inverse of the difference between the bin's size and the item's size, and the inverse of the sum of the bin's rest capacity and the item's size.\",\n \"code\": \"def score(item, bins):\\n reciprocal_product = 1 / (bins * np.arange(1, len(bins) + 1))\\n reciprocal_diff = 1 / np.maximum(bins - item, 1e-6)\\n reciprocal_sum = 1 / np.maximum(bins + item, 1e-6)\\n scores = reciprocal_product + reciprocal_diff + reciprocal_sum\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score by adding the inverse of the available capacity divided by the bin size, and multiplying it by the bin size.\",\n \"code\": \"def score(item, bins):\\n scores = bins / (bins - item + 1e-9) * item\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_LLMs/TC2T2Cgemini+gemini/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with the bin's index minus half of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n inv_abs_diff = 1 / np.abs(bins - item)\\n sqrt_size = np.sqrt(bins)\\n exp_product = np.exp((bins - item/2) * np.arange(len(bins)))\\n scores = inv_abs_diff * sqrt_size * exp_product\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign to bins that are closer to their maximum capacity without violating the given constraint, and penalize bins for being much larger than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins / item) * (bins <= 2 * item) * (bins != 0)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with its index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate the score for each bin based on the product of the inverse of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's size, and the exponential of the product of the bin's rest capacity with its index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the absolute difference between the item size and the bin's rest capacity.\\n abs_diff = np.abs(bins - item)\\n\\n # Calculate the inverse of the absolute difference.\\n inv_abs_diff = 1 / abs_diff\\n\\n # Calculate the square root of the bin's size.\\n sqrt_size = np.sqrt(bins)\\n\\n # Calculate the exponential of the product of the bin's rest capacity with its index.\\n exp_product = np.exp(bins * np.arange(len(bins)))\\n\\n # Calculate the score for each bin.\\n scores = inv_abs_diff * sqrt_size * exp_product\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: Calculate the score for each bin based on the inverse of the distance between the item size and the bin's rest capacity, the square of the exponential of the product of the bin's rest capacity and its index, and the square root of the bin's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs(bins - item) * np.square(np.exp(bins * np.arange(1, len(bins) + 1))) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\",\n \"code\": \"import math\\nimport numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculates the score of a bin as the product of the inverse of the square root of bin available capacity, sqrt of bin index, and the size of the bin.\\n\\n Args:\\n item: Size of current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = np.sqrt(1.0 / (np.sqrt(available_capacity) * np.sqrt(np.arange(len(bins)) + 1))) * bins\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Adjusted algorithm: Penalize bins based on their remaining capacity and their difference to the item size by combining the ideas from algorithms 1 and 3.\\nCode:\\nimport numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / (1. + remaining) * 1. / (1. + np.abs(remaining - item))\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Prioritize bins based on their remaining capacity while penalizing bins with large differences between their remaining capacity and the item size by combining the ideas from algorithms 1, 2, and 4.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n remaining = bins - item\\n scores = 1. / ((1. + remaining) * (1. + np.abs(remaining - item)))\\n return scores\",\n \"objective\": 0.03129,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"Calculate bin score.\\n\\n Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index.\\n\\n Args:\\n item: The size of current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n available_capacity = bins - item\\n scores = 1.0 / available_capacity**2 + np.sqrt(available_capacity / item) / np.arange(1.0, len(bins) + 1.0)\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a score function that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Computes a score for each bin that is proportional to the bin's rest capacity and inversely proportional to its index, but with a penalty determined by the ratio between the bin's rest capacity and the item size.\\n\\n Args:\\n item: The size of the current item.\\n bins: A Numpy array containing the rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array containing the scores for the bins.\\n \\\"\\\"\\\"\\n\\n # Compute the rest capacity ratio for each bin.\\n ratio = bins / item\\n\\n # Compute the score for each bin.\\n scores = ratio / (np.arange(len(bins)) + 1)\\n\\n # Penalize bins with a low rest capacity ratio.\\n scores[ratio < 1.5] /= ratio[ratio < 1.5]\\n\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm uses the product of the bins' inverse index, the inverse of the bins' available capacity, and a weighted sum of the item size and the bin size as the score function.\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n scores = bins / (np.array(range(len(bins))) + 1) * (1/(bins - item) + 1./item + 1.)\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \" Assign each bin a score that is the sum of the inverse of the square of the difference between the bin's size and the item's size, and the inverse of the product of the bin's rest capacity and its index. \",\n \"code\": \"import numpy as np\\n\\ndef score(item: int, bins: np.ndarray) -> np.ndarray:\\n scores = 1 / (bins - item) ** 2 + 1 / (bins * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculates the score of a bin as the product of the inverse of bin index, the inverse of bin available capacity, and a function of item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(1 + np.arange(1, len(bins) + 1)) / (bins - item)\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Score function is the product of inverse square root of the bin available capacity, the inverse of the square root of the bin index, and the bin size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = (1 / np.sqrt(available_capacity)) * (1 / np.sqrt(np.arange(1, len(bins) + 1))) * item\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the bin score as the product of the exponent of the inverse of the difference between the bin size and the item size, and the exponent of the inverse of the product of the bin size and the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.power(1 / (bins - item), 2) * np.power(1 / (bins * np.arange(1, len(bins) + 1)), 2)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the score for each bin based on the following: the inverse of the square of the difference between the item size and the bin's rest capacity, the inverse of the product of the bin's index and its rest capacity, and the square of the bin's size.\",\n \"code\": \"def score(item, bins):\\n # Calculate the score for each bin\\n scores = (1 / ((item - bins) ** 2)) * (1 / (np.arange(1, bins.size + 1) * bins)) * (bins ** 2)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the score for each bin as the product of the inverse of the square of the absolute difference between the item size and the bin's rest capacity, the square root of the bin's rest capacity, and the inverse of the bin's index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between the item size and the bin's rest capacity\\n diffs = np.abs(bins - item)\\n # Calculate the inverse of the square of the absolute difference\\n inv_sq_diffs = 1 / diffs**2\\n # Calculate the square root of the bin's rest capacity\\n sqrt_capacities = np.sqrt(bins)\\n # Calculate the inverse of the bin's index\\n inv_indices = 1 / np.arange(1, bins.size + 1)\\n # Calculate the score for each bin\\n scores = inv_sq_diffs * sqrt_capacities * inv_indices\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate bin score as the sum of the inverse square of available capacity and the square root of the rest capacity to item size ratio, and divide by the bin index and the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Calculate bin score for an item.\\n\\n Args:\\n item: Size of the current item.\\n bins: Rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n Scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n available_capacity = np.maximum(bins - item, 0)\\n ratio = np.maximum(available_capacity / item, 1)\\n scores = (1 / available_capacity**2 + np.sqrt(ratio)) / np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign each bin a score that is the sum of the inverse of the product of the bin's rest capacity and its index, and the inverse of the difference between the bin's size and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"Score a set of bins to assign an item.\\n\\n Args:\\n item: The size of the current item.\\n bins: The rest capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores: The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the inverse of the product of the bin's rest capacity and its index.\\n inv_prod_cap_idx = 1 / (bins * np.arange(1, len(bins) + 1))\\n\\n # Calculate the inverse of the difference between the bin's size and the item's size.\\n inv_diff_size = 1 / (bins - item)\\n\\n # Sum the two inverse values to get the score for each bin.\\n scores = inv_prod_cap_idx + inv_diff_size\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the score of a bin as the product of the inverse of the bin's rest capacity and the sum of the inverse of the absolute difference between the bin's size and the item's size and the inverse of the product of the bin's rest capacity and its index.\",\n \"code\": \"def score(item: int, bins: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Compute the score of each bin for assigning an item.\\n\\n Args:\\n item: The size of the item to be assigned.\\n bins: A Numpy array of the rest capacities of the feasible bins, which are larger than the item size.\\n\\n Returns:\\n A Numpy array of the scores for the bins.\\n \\\"\\\"\\\"\\n # Compute the absolute difference between the bin sizes and the item size.\\n diff = np.abs(bins - item)\\n\\n # Compute the inverse of the bin rest capacities.\\n inv_cap = 1 / bins\\n\\n # Compute the inverse of the absolute difference between the bin sizes and the item size.\\n inv_diff = 1 / diff\\n\\n # Compute the inverse of the product of the bin rest capacities and their indices.\\n inv_prod = 1 / (bins * np.arange(1, len(bins) + 1))\\n\\n # Compute the score for each bin.\\n scores = inv_cap * (inv_diff + inv_prod)\\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Modified algorithm: Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\\"\\\"\\\"\\n Score bins based on their remaining capacity multiplied by their difference to the item size, then favor bins with lower remaining capacity.\\n\\n Args:\\n item (int): The size of the current item.\\n bins (np.array): The remaining capacities of feasible bins, which are larger than the item size.\\n\\n Returns:\\n scores (np.array): The scores for the bins for assignment.\\n \\\"\\\"\\\"\\n\\n # Calculate the difference between the remaining capacity of each bin and the item size.\\n diff = bins - item\\n\\n # Calculate the score for each bin based on its remaining capacity and difference to the item size.\\n scores = diff * (bins / diff)\\n\\n # Favor bins with lower remaining capacity.\\n scores /= bins\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the score for each bin by taking the number of items that can fit into the bin without exceeding its capacity, and subtracting the rest capacity of the bin from the maximum capacity.\\n\\nSteps:\\n1. Create an empty numpy array named 'scores' with the same shape as the 'bins' array.\\n2. Iterate through each bin in the 'bins' array.\\n3. Calculate the score for the bin by subtracting the rest capacity of the bin from the maximum capacity.\\n4. Replace the corresponding element in the 'scores' array with the calculated score.\\n5. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n scores[i] = max_capacity - bins[i]\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns items to bins based on a score function that maximizes the score. It avoids using bins with rest capacity equal to the maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = item / bins[mask] # Calculate scores for the remaining bins using the formula item / capacity\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: First, calculate the remaining capacity of each bin after considering the current item. Next, calculate the score for each bin by multiplying the remaining capacity by the number of unused bins (i.e., bins with remaining capacity equal to the maximum capacity). Finally, return the scores for all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n unused_bins = np.sum(remaining_capacity == max_capacity)\\n scores = remaining_capacity * unused_bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, and if the rest capacity equals the maximum capacity, the score is set to -1. \\nNext, it returns a Numpy array of the calculated scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = bins[i] / item\\n \\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We will assign a score to each bin based on the ratio of the bin capacity to the item size, making sure that bins with no remaining capacity have a score of zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores with zeros\\n scores[bins > item] = bins[bins > item] / item # Calculate scores based on the ratio of bin capacity to item size\\n scores[bins == np.max(bins)] = 0 # Set scores of bins with maximum capacity to zero\\n return scores\",\n \"objective\": 0.06912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm scores a set of bins to assign an item by maximizing the score of each bin, while ensuring that bins with maximum capacity are not used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm consists of the following steps:\\n- Calculate the remaining capacities of the bins after considering the current item.\\n- Assign a score of 0 to bins that have a remaining capacity equal to the maximum capacity.\\n- For the rest of the bins, calculate the score as the ratio of remaining capacity to the difference between the maximum and current capacity.\\n- Return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacities = bins - item\\n scores = np.zeros_like(bins)\\n scores[remaining_capacities == max_capacity] = 0\\n scores[remaining_capacities != max_capacity] = remaining_capacities[remaining_capacities != max_capacity] / (max_capacity - remaining_capacities[remaining_capacities != max_capacity])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm assigns an item to a bin by calculating a score for each bin based on its remaining capacity and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the remaining capacity of each bin\\n remaining_capacity = bins - item\\n \\n # Initialize an array to store the scores for each bin\\n scores = np.zeros_like(bins)\\n \\n # Calculate the score for each bin based on remaining capacity\\n scores = np.where(remaining_capacity > 0, remaining_capacity, np.inf)\\n \\n # Exclude bins with maximum capacity from being used\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, np.inf, scores)\\n \\n # Return the scores for the bins\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Create an empty Numpy array 'scores' to store the scores for the bins.\\n2. Calculate the maximum capacity 'max_capacity' from the 'bins' array.\\n3. If 'max_capacity' is equal to 'item', return 'scores' array as it implies the bin with maximum capacity will not be used.\\n4. Otherwise, create a mask of feasible bins where the rest capacity is greater than 'item'.\\n5. Use the mask to select the feasible bins from the 'bins' array.\\n6. Calculate the scores for each feasible bin by dividing the rest capacity by the difference between 'max_capacity' and 'item'. This will prioritize bins with higher rest capacity and lower difference from 'max_capacity'.\\n7. Assign the calculated scores to the respective indices in the 'scores' array.\\n8. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty(len(bins), dtype=np.float64) # Step 1\\n \\n max_capacity = np.max(bins) # Step 2\\n \\n if max_capacity == item: # Step 3\\n return scores\\n \\n feasible_mask = bins > item # Step 4\\n feasible_bins = bins[feasible_mask] # Step 5\\n \\n scores[feasible_mask] = feasible_bins / (max_capacity - item) # Step 6\\n \\n return scores\",\n \"objective\": 1.1474,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the largest score, while ensuring that the bin's remaining capacity is not equal to the maximum capacity. The main steps are: Initialize an array of scores with zeros, iterate over the bins, calculate the score for each bin based on its remaining capacity and whether it is already full, and return the array of scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(bins.shape)\\n for i in range(len(bins)):\\n remaining_capacity = bins[i] - item\\n scores[i] = remaining_capacity if remaining_capacity < bins[i] else -np.inf\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) - np.abs(diff[diff >= 0])\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm is as follows: First, calculate the remaining capacity of each bin after considering the current item. Next, calculate the score for each bin by dividing the remaining capacity by the number of unused bins (i.e., bins with remaining capacity equal to the maximum capacity), and then multiplying it by the square root of the remaining capacity. Finally, return the scores for all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n unused_bins = np.sum(remaining_capacity == max_capacity)\\n scores = (remaining_capacity / unused_bins) * np.sqrt(remaining_capacity)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: First, calculate the remaining capacity of each bin after considering the current item. Next, calculate the score for each bin by multiplying the remaining capacity by the number of unused bins (i.e., bins with remaining capacity equal to the maximum capacity). Finally, return the scores for all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n unused_bins = np.sum(remaining_capacity == max_capacity)\\n scores = remaining_capacity * unused_bins\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: \\n1. Multiply the item size by the remaining capacity of each bin.\\n2. Divide the result by the number of unused bins (i.e., bins with remaining capacity equal to the maximum capacity).\\n3. Subtract the item size from the remaining capacity of each bin.\\n4. Take the square root of the result obtained in step 3.\\n5. Multiply the result obtained in step 2 by the result obtained in step 4.\\n6. Return the scores for all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n unused_bins = np.sum(remaining_capacity == max_capacity)\\n scores = (item * remaining_capacity) / unused_bins\\n scores -= np.sqrt(remaining_capacity - item)\\n scores *= np.sqrt(remaining_capacity)\\n\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified score function that takes into account both the item size and the remaining capacity of each bin. It aims to maximize the score while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = (item / bins[mask]) * np.exp(1 - bins[mask] / np.max(bins)) # Calculate modified scores for the remaining bins\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm first calculates the ratio between each bin's rest capacity and the item size, and then takes the square root of the ratio. Bins with rest capacity equal to the maximum capacity are assigned a score of zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = (bins < np.max(bins)) \\n scores[mask] = np.sqrt(bins[mask] / item)\\n return scores\",\n \"objective\": 0.04769,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm first calculates the ratio between each bin's rest capacity and the item size, and then takes the square root of the ratio. Bins with rest capacity equal to the maximum capacity are assigned a score of zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = (bins < np.max(bins)) \\n scores[mask] = bins[mask] / item\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We will assign a score to each bin based on the ratio of the bin capacity to the item size, making sure that bins with no remaining capacity have a score of zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores with zeros\\n scores[bins > item] = bins[bins > item] / item # Calculate scores based on the ratio of bin capacity to item size\\n scores[bins == np.max(bins)] = 0 # Set scores of bins with maximum capacity to zero\\n return scores\",\n \"objective\": 0.06912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm first calculates the difference between each bin's rest capacity and the item size, adds the square of this difference to the bin's index position, and assigns a score of zero to bins with rest capacity equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = (bins < np.max(bins)) \\n scores[mask] = (bins[mask] - item) ** 2 + np.arange(bins.shape[0])[mask]\\n return scores\",\n \"objective\": 0.1307,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the squared root of the remaining capacity and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] * item_inverse\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the natural logarithm of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.log(remaining_capacity[mask]) * (1/item)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the log base 10 of the remaining capacity and the cube root of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.log10(remaining_capacity[mask]) * (item**(1/3)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the reciprocal of the difference between the rest capacity and the item size by the logarithm of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n # Revised algorithm parameters\\n k = 1.5 * np.log(item) / np.log(np.max(bins))\\n m = 0.5 * np.log(item) / np.log(np.max(bins))\\n \\n scores[diff >= 0] = k * np.log(bins[diff >= 0]) / ((diff[diff >= 0] + 1e-6) ** m)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the reciprocal of the difference between the rest capacity and the item size by the logarithm of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n # New algorithm parameters\\n k = 1.5\\n m = 0.5\\n \\n scores[diff >= 0] = k * np.log(bins[diff >= 0]) / ((diff[diff >= 0] + 1e-6) ** m)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the reciprocal of the difference between the rest capacity and the item size, multiplied by the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the squared root of the remaining capacity and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the product of the remaining capacity and the inverse of the item size, multiplied by the difference between the remaining capacity and the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the natural logarithm of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.log(remaining_capacity[mask]) * (1/item)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the natural logarithm of the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.log(remaining_capacity[mask]) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin by taking the reciprocal of the difference between the rest capacity and the item size, multiplied by the square root of the maximum capacity minus the rest capacity, and assigning a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n \\n scores[mask] = np.sqrt(bins.max() - remaining_capacity[mask]) / (remaining_capacity[mask] + 1e-6)\\n scores[~mask] = 0\\n \\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the squared root of the remaining capacity and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the product of the remaining capacity and the inverse of the item size, multiplied by the difference between the remaining capacity and the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by summing the square of the item size and the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = item**2 + remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the natural logarithm of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.log(remaining_capacity[mask]) * (1/item)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the product of the remaining capacity and the inverse of the item size, multiplied by the difference between the remaining capacity and the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by summing the square of the item size and the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = item**2 + remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the natural logarithm of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.log(remaining_capacity[mask]) * (1/item)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the product of the remaining capacity and the inverse of the item size, multiplied by the difference between the remaining capacity and the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the inverse of the remaining capacity and the item size, and incorporating the square root and natural logarithm of the remaining capacity and item size, respectively, multiplied by the inverse of the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = ((remaining_capacity[mask]**0.5) * np.log(remaining_capacity[mask]) * (1 / item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.02395,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by summing the square of the item size and the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = item**2 + remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the product of the remaining capacity and the inverse of the item size, multiplied by the difference between the remaining capacity and the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the product of the remaining capacity and the inverse of the item size, multiplied by the difference between the remaining capacity and the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sin(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01841,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n scores = (bins - item)**0.5 * (bins - 2*item) / (2*item)\\n scores[bins >= bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the product of the remaining capacity and the inverse of the item size, multiplied by the difference between the remaining capacity and the item size, only for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt(remaining_capacity[mask] * (1/item)) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n scores = (bins - item)**0.5 * (bins - 2*item) / (2*item)\\n scores[bins >= bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n scores = (bins - item)**0.5 * (bins - 2*item) / (2*item)\\n scores[bins >= bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n item_inverse = 1 / item\\n \\n mask = (bins < max_capacity)\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) * item_inverse\\n \\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) - np.abs(diff[diff >= 0])\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"np.log(bins) * np.exp(item/bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n \\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.log(bins[mask]) * np.exp(item/bins[mask]) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by first calculating the ratio of the rest capacity of the bin to the item size, then taking the inverse of the square root of the ratio. If the rest capacity is less than the item size, the score is set to zero. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n ratio = bins / item\\n scores[ratio >= 1] = 1 / np.sqrt(ratio[ratio >= 1])\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the square root of the bin capacity and the inverse of the item size, excluding bins with no remaining capacity or the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.sqrt(bins[mask]) * (1/item) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n item_inverse = 1 / item\\n \\n mask = (bins < max_capacity)\\n scores[mask] = np.sqrt(remaining_capacity[mask]) * item_inverse\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: \\n1. Multiply the item size by the remaining capacity of each bin.\\n2. Divide the result by the number of unused bins (i.e., bins with remaining capacity equal to the maximum capacity).\\n3. Subtract the item size from the remaining capacity of each bin.\\n4. Take the square root of the result obtained in step 3.\\n5. Multiply the result obtained in step 2 by the result obtained in step 4.\\n6. Return the scores for all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n unused_bins = np.sum(remaining_capacity == max_capacity)\\n scores = (item * remaining_capacity) / unused_bins\\n scores -= np.sqrt(remaining_capacity - item)\\n scores *= np.sqrt(remaining_capacity)\\n\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified score function that takes into account both the item size and the remaining capacity of each bin. It aims to maximize the score while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = (item / bins[mask]) * np.exp(1 - bins[mask] / np.max(bins)) # Calculate modified scores for the remaining bins\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm assigns a score to each bin based on the difference between the square root of the remaining capacity and the square root of the item size, multiplied by the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (np.sqrt(remaining_capacity[mask]) - np.sqrt(item)) * np.sqrt(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_26.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity. The new algorithm modifies the parameter settings of the score function by multiplying the square root of the item size with the logarithm of the remaining capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * np.sqrt(item_sqrt_inverse) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_27.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity. The new algorithm modifies the parameter settings of the score function by multiplying the square root of the item size with the logarithm of the remaining capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * np.sqrt(item_sqrt_inverse) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_28.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity. The new algorithm modifies the parameter settings of the score function by multiplying the square root of the item size with the logarithm of the remaining capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * np.sqrt(item_sqrt_inverse) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_29.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity. The new algorithm modifies the parameter settings of the score function by multiplying the square root of the item size with the logarithm of the remaining capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * np.sqrt(item_sqrt_inverse) * (remaining_capacity[mask] - item) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) - np.abs(diff[diff >= 0])\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"np.log(bins) * np.exp(item/bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n \\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.log(bins[mask]) * np.exp(item/bins[mask]) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by first calculating the ratio of the rest capacity of the bin to the item size, then taking the inverse of the square root of the ratio. If the rest capacity is less than the item size, the score is set to zero. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n ratio = bins / item\\n scores[ratio >= 1] = 1 / np.sqrt(ratio[ratio >= 1])\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the square root of the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size or the item size is equal to the maximum capacity, the score is set to zero.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = np.sqrt((np.max(bins) - item) / (bins[mask])) # Calculate scores for the remaining bins\\n \\n scores[bins < item] = 0 # Set score to zero for bins with rest capacity less than item size\\n scores[item == np.max(bins)] = 0 # Set score to zero for bins with rest capacity equal to maximum capacity\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = (np.max(bins) - item) / (bins[mask]) # Calculate scores for the remaining bins\\n \\n scores[bins < item] = 0 # Set score to zero for bins with rest capacity less than item size\\n \\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the square root of the bin capacity divided by the item size, excluding bins with no remaining capacity or the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.sqrt(bins[mask]) / item # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n item_inverse = 1 / item\\n \\n mask = (bins < max_capacity)\\n scores[mask] = np.sqrt(remaining_capacity[mask]) * item_inverse\\n \\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_30.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the sigmoid function of the natural logarithm of the remaining capacity divided by the item size, for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef sigmoid(x):\\n return 1 / (1 + np.exp(-x))\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * sigmoid(np.log(remaining_capacity[mask]) / item)\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_31.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the sigmoid function of the natural logarithm of the remaining capacity divided by the item size, for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef sigmoid(x):\\n return 1 / (1 + np.exp(-x))\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * sigmoid(np.log(remaining_capacity[mask]) / item)\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_32.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the sigmoid function of the natural logarithm of the remaining capacity divided by the item size, for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef sigmoid(x):\\n return 1 / (1 + np.exp(-x))\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * sigmoid(np.log(remaining_capacity[mask]) / item)\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_33.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = np.where(bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the reciprocal of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * (1/item) * (1/(item**0.5)) * np.log(item)\\n\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_34.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n smoothing_factor = 0.5 # Smoothing factor for enhanced generalization\\n \\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item + smoothing_factor) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = bins < bins.max()\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity of the bin and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively. Additionally, it takes into account the inverse of the square root of the item size and the logarithm of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n item_sqrt_inverse = 1 / (item**0.5)\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) * item_inverse * item_sqrt_inverse\\n\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_35.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the difference between the remaining capacity and the item size, and then apply various mathematical operations to this difference.\\n\\nBased on this backbone idea, my new algorithm assigns scores to bins by taking the square root of the ratio between the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and then dividing it by the logarithm of the remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)) / np.log(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n smoothing_factor = 0.5 # Smoothing factor for enhanced generalization\\n \\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item + smoothing_factor) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = bins < bins.max()\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_36.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the difference between the remaining capacity and the item size, and then apply various mathematical operations to this difference.\\n\\nBased on this backbone idea, my new algorithm assigns scores to bins by taking the square root of the ratio between the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and then dividing it by the logarithm of the remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)) / np.log(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n smoothing_factor = 0.5 # Smoothing factor for enhanced generalization\\n \\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item + smoothing_factor) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = bins < bins.max()\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_37.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the difference between the remaining capacity and the item size, and then apply various mathematical operations to this difference.\\n\\nBased on this backbone idea, my new algorithm assigns scores to bins by taking the square root of the ratio between the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and then dividing it by the logarithm of the remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)) / np.log(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n threshold = 0.8 # Set a threshold value\\n\\n mask = (bins < threshold * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max()) \\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item + 0.5) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = bins < bins.max()\\n scores[mask] = (remaining_capacity[mask]**0.5) * np.log2(item) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_38.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the difference between the remaining capacity and the item size, and then apply various mathematical operations to this difference.\\n\\nBased on this backbone idea, my new algorithm assigns scores to bins by taking the square root of the ratio between the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and then dividing it by the logarithm of the remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)) / np.log(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < 0.8 * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max()) \\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item + 0.5) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the difference between the remaining capacity and the item size, and then apply various mathematical operations to this difference.\\n\\nBased on this backbone idea, my new algorithm assigns scores to bins by taking the square root of the ratio between the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and then dividing it by the logarithm of the remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / np.log(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_39.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the difference between the remaining capacity and the item size, and then apply various mathematical operations to this difference.\\n\\nBased on this backbone idea, my new algorithm assigns scores to bins by taking the square root of the ratio between the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and then dividing it by the logarithm of the remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)) / np.log(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < 0.8 * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max()) \\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item + 0.5) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the ratio of the remaining capacity to the item size, multiplied by the difference between the remaining capacity and the item size. If the remaining capacity equals the maximum capacity, it will not be used. \\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < 0.8 * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) - np.abs(diff[diff >= 0])\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"np.log(bins) * np.exp(item/bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n \\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.log(bins[mask]) * np.exp(item/bins[mask]) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by first calculating the ratio of the rest capacity of the bin to the item size, then taking the inverse of the square root of the ratio. If the rest capacity is less than the item size, the score is set to zero. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n ratio = bins / item\\n scores[ratio >= 1] = 1 / np.sqrt(ratio[ratio >= 1])\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the square root of the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size or the item size is equal to the maximum capacity, the score is set to zero.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = np.sqrt((np.max(bins) - item) / (bins[mask])) # Calculate scores for the remaining bins\\n \\n scores[bins < item] = 0 # Set score to zero for bins with rest capacity less than item size\\n scores[item == np.max(bins)] = 0 # Set score to zero for bins with rest capacity equal to maximum capacity\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = (np.max(bins) - item) / (bins[mask]) # Calculate scores for the remaining bins\\n \\n scores[bins < item] = 0 # Set score to zero for bins with rest capacity less than item size\\n \\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the logarithm of the bin capacity divided by the item size, excluding bins with no remaining capacity or the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.log(bins[mask]) / item # Calculate scores for the remaining bins with the logarithm function\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the square root of the bin capacity divided by the item size, excluding bins with no remaining capacity or the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.sqrt(bins[mask]) / item # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_40.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the hyperbolic tangent function of the natural logarithm of the remaining capacity and the square of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.tanh(np.log(remaining_capacity[mask]) * item**2)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin based on the ratio of the remaining capacity to the square of the item size, multiplied by the difference between the remaining capacity and the item size, and then takes the square root of the result.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / (item**2)) * (remaining_capacity[mask] - item))\\n\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the difference between the remaining capacity and the item size, and then apply various mathematical operations to this difference.\\n\\nBased on this backbone idea, my new algorithm assigns scores to bins by taking the square root of the ratio between the remaining capacity and the item size, multiplied by the difference between the remaining capacity and the item size, and then dividing it by the logarithm of the remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = np.sqrt((remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)) / np.log(remaining_capacity[mask])\\n\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < 0.8 * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the difference between remaining capacity and item size, divided by the sum of remaining capacity and item size, and then multiplied by the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max()) \\n scores[mask] = (remaining_capacity[mask] - item) / (remaining_capacity[mask] + item + 0.5) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the inverse of the remaining capacity and the item size, and incorporates the square root and logarithm of the remaining capacity and item size, respectively.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask]**0.5) * (remaining_capacity[mask] - item) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the remaining capacity squared and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * (remaining_capacity[mask]**2) / item\\n\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the product of remaining capacity, inverse of item size, and the difference between remaining capacity and item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] / item\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores based on the ratio of the remaining capacity to the item size, multiplied by the difference between the remaining capacity and the item size. If the remaining capacity equals the maximum capacity, it will not be used. \\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < 0.8 * bins.max()) # Simplified mask condition\\n scores[mask] = (remaining_capacity[mask] / item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) - np.abs(diff[diff >= 0])\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"np.log(bins) * np.exp(item/bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n \\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.log(bins[mask]) * np.exp(item/bins[mask]) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by first calculating the ratio of the rest capacity of the bin to the item size, then taking the inverse of the square root of the ratio. If the rest capacity is less than the item size, the score is set to zero. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n ratio = bins / item\\n scores[ratio >= 1] = 1 / np.sqrt(ratio[ratio >= 1])\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the square root of the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size or the item size is equal to the maximum capacity, the score is set to zero.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = np.sqrt((np.max(bins) - item) / (bins[mask])) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm takes the product of the natural logarithm of the remaining capacity ratio and the square root of the ratio, subtracts the exponential of the ratio, and finally adds the square root of the remaining capacity ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n ratio = bins / item\\n scores[ratio >= 1] = np.log(ratio[ratio >= 1]) * np.sqrt(ratio[ratio >= 1]) - np.exp(ratio[ratio >= 1]) + np.sqrt(ratio[ratio >= 1])\\n\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = (np.max(bins) - item) / (bins[mask]) # Calculate scores for the remaining bins\\n \\n scores[bins < item] = 0 # Set score to zero for bins with rest capacity less than item size\\n \\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by first calculating the logarithm of the ratio between the rest capacity of the bin and the item size, then taking the square of the logarithm and subtracting the square root of the rest capacity. If the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n ratio = bins / item\\n scores[ratio >= 1] = np.log(ratio[ratio >= 1]) ** 2 - np.sqrt(bins[ratio >= 1])\\n \\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) - np.abs(diff[diff >= 0])\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the inverse of the remaining capacity ratio, then subtracts the square root of the product of the ratio and the item size, and finally multiplies it by the log of the ratio.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n item_sqrt = math.sqrt(item)\\n scores = np.zeros_like(bins)\\n\\n ratio = bins / item\\n scores[ratio >= 1] = (1 / np.sqrt(ratio[ratio >= 1])) - (np.sqrt(ratio[ratio >= 1] * item) * item_sqrt) + (np.log(ratio[ratio >= 1]) * item_sqrt)\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"np.log(bins) * np.exp(item/bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n \\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n scores[mask] = np.log(bins[mask]) * np.exp(item/bins[mask]) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by first calculating the ratio of the rest capacity of the bin to the item size, then taking the inverse of the square root of the ratio. If the rest capacity is less than the item size, the score is set to zero. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n ratio = bins / item\\n scores[ratio >= 1] = 1 / np.sqrt(ratio[ratio >= 1])\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the square root of the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size or the item size is equal to the maximum capacity, the score is set to zero.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = np.sqrt((np.max(bins) - item) / (bins[mask])) # Calculate scores for the remaining bins\\n \\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the item size and the inverse of the logarithm of the rest capacity, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = item * (1 / np.log(bins[mask])) # Calculate scores for the remaining bins\\n \\n scores[bins < item] = 0 # Set score to zero for bins with rest capacity less than item size\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the square root of the inverse of the remaining capacity ratio, subtracts the square root of the product of the ratio and the item size, and finally adds the square root of the ratio.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n ratio = bins / item\\n scores[ratio >= 1] = np.sqrt(1 / ratio[ratio >= 1]) - np.sqrt(ratio[ratio >= 1] * item) + np.sqrt(ratio[ratio >= 1])\\n\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the difference between the maximum capacity and the item size divided by the remaining capacity of the bin, excluding bins with no remaining capacity or the maximum capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n mask = (bins < np.max(bins)) # Create a mask to exclude bins with rest capacity equal to the maximum capacity\\n \\n scores[mask] = (np.max(bins) - item) / (bins[mask]) # Calculate scores for the remaining bins\\n \\n scores[bins < item] = 0 # Set score to zero for bins with rest capacity less than item size\\n \\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) * item_inverse\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the reciprocal of the difference between the rest capacity and the item size, multiplied by the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the square of the item size by the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.square(item) / bins[diff >= 0]\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by subtracting the absolute difference between the rest capacity and the item size from the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) - np.abs(diff[diff >= 0])\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the sum of the capacity and the item size, subtracting the square root of the product of the capacity and the item size, multiplying it by the logarithm of the sum of capacity and one, and finally, multiplying it by the log of the maximum capacity minus the capacity of the bin plus one.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n max_capacity = np.max(bins)\\n scores = np.sqrt(bins + item) - np.sqrt(bins * item) + np.log(bins + 1) * np.log(max_capacity - bins + 1)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the inverse of the remaining capacity ratio, then subtracts the square root of the product of the ratio and the item size, and finally multiplies it by the log of the ratio.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n item_sqrt = math.sqrt(item)\\n scores = np.zeros_like(bins)\\n\\n ratio = bins / item\\n scores[ratio >= 1] = (1 / np.sqrt(ratio[ratio >= 1])) - (np.sqrt(ratio[ratio >= 1] * item) * item_sqrt) + (np.log(ratio[ratio >= 1]) * item_sqrt)\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"np.log(bins) * np.exp(item/bins)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n mask = (bins < np.max(bins))\\n scores[mask] = np.log(bins[mask]) * np.exp(item/bins[mask])\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by first calculating the ratio of the rest capacity of the bin to the item size, then taking the inverse of the square root of the ratio. If the rest capacity is less than the item size, the score is set to zero. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n ratio = bins / item\\n scores[ratio >= 1] = 1 / np.sqrt(ratio[ratio >= 1])\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) * (1/item)\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] * item_inverse\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the natural logarithm of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.log(remaining_capacity[mask]) * (1/item)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the reciprocal of the difference between the rest capacity and the item size, multiplied by the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the reciprocal of the difference between the rest capacity and the item size, multiplied by the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = bins[diff >= 0] / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = 0\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the reciprocal of the difference between the rest capacity and the item size by the logarithm of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.log(bins[diff >= 0]) / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the rest capacity and the item size, and subtracting the square of the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * item - bins**2\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by dividing the sum of the reciprocal of the difference between the rest capacity and the item size by the logarithm of the rest capacity, and sets the score to a large negative value if the rest capacity is less than the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sum(1 / (diff[diff >= 0] + 1e-6)) / np.log(bins[diff >= 0])\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the square of the item size by the rest capacity, and if the rest capacity is less than the item size, the score is set to zero.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.square(item) / bins[diff >= 0]\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the squared root of the remaining capacity and divided by the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.sqrt(remaining_capacity[mask]) / item\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n item_inverse = 1 / item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask] * item_inverse\\n\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: My new algorithm calculates the score for each bin by taking the product of the remaining capacity and the logarithm base 2 of the item size, multiplied by the difference between the remaining capacity and the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = remaining_capacity[mask] * np.log2(item) * (remaining_capacity[mask] - item)\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the square root of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * remaining_capacity[mask]\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the difference between the remaining capacity and the item size, multiplied by the natural logarithm of the remaining capacity and the inverse of the item size for bins where the remaining capacity is not equal to the maximum capacity, and assigns a score of zero for bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n mask = (bins < bins.max())\\n scores[mask] = (remaining_capacity[mask] - item) * np.log(remaining_capacity[mask]) * (1/item)\\n\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the reciprocal of the difference between the rest capacity and the item size by the logarithm of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n # Revised algorithm parameters\\n k = 1.5 * np.log(item) / np.log(np.max(bins))\\n m = 0.5 * np.log(item) / np.log(np.max(bins))\\n \\n scores[diff >= 0] = k * np.log(bins[diff >= 0]) / ((diff[diff >= 0] + 1e-6) ** m)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the reciprocal of the difference between the rest capacity and the item size by the logarithm of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n # New algorithm parameters\\n k = 1.5\\n m = 0.5\\n \\n scores[diff >= 0] = k * np.log(bins[diff >= 0]) / ((diff[diff >= 0] + 1e-6) ** m)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the reciprocal of the difference between the rest capacity and the item size, multiplied by the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.sqrt(bins[diff >= 0]) / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the reciprocal of the difference between the rest capacity and the item size, multiplied by the square root of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = bins[diff >= 0] / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = 0\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm multiplies the reciprocal of the difference between the rest capacity and the item size by the logarithm of the rest capacity, and if the rest capacity is less than the item size, the score is set to a large negative value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n diff = bins - item\\n \\n scores[diff >= 0] = np.log(bins[diff >= 0]) / (diff[diff >= 0] + 1e-6)\\n scores[diff < 0] = -1e6\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"The new algorithm called \\\"score\\\" takes an item and a set of bin capacities as input and returns a score for each bin, based on which the item will be assigned to the bin with the maximum score, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -np.inf\\n else:\\n scores[i] = max_capacity - bins[i]\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows:\\n1. Calculate the remaining capacities of the bins after allocating the current item to each bin.\\n2. Initialize an empty scores array with the same length as the bins array.\\n3. Iterate over each bin and calculate a score based on the remaining capacity of the bin and the maximum capacity among all the bins.\\n4. Store the score in the corresponding index of the scores array.\\n5. Return the scores array.\\n\\nHere is the implementation of the score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n max_capacity = np.max(bins)\\n\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = remaining_capacities[i] / max_capacity\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the remaining capacity of the bin by a weight factor, which is the inverse of the bin index raised to the power of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(len(bins), 0, -1)**2\\n scores = bins * weights\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm assigns an item to a bin by calculating a score for each bin based on their residual capacities, and returns the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != np.max(bins)] = (bins[bins != np.max(bins)]) / (np.max(bins) - bins[bins != np.max(bins)])\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nIn this algorithm, the main steps are calculating the scores for each bin based on their rest capacities, assigning the item to the bin with the maximum score, and returning the scores for all bins after the assignment is complete.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != np.max(bins)] = item / (bins[bins != np.max(bins)] - item)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score by calculating the score for each bin based on its rest capacity, where the score is inversely proportional to the rest capacity, and bins with maximum rest capacity are not used. \\nFirst, create an array 'weights' by dividing 1 by each rest capacity in 'bins'.\\nNext, calculate 'total_weight' as the sum of all weights in 'weights'.\\nThen, calculate 'normalized_weights' by dividing each weight in 'weights' by 'total_weight'.\\nFinally, calculate 'scores' by multiplying 'normalized_weights' with 'bins'.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / bins.astype(float)\\n total_weight = np.sum(weights)\\n normalized_weights = weights / total_weight\\n scores = normalized_weights * bins\\n return scores\",\n \"objective\": 0.05554,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where the item is assigned to the bin with the maximum score. Unused bins are those with a rest capacity equal to the maximum capacity, and the goal is to minimize their number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins) # get the maximum capacity from the rest capacities of bins\\n scores = np.where(bins == max_capacity, 0, bins - item) # assign 0 score to unused bins and subtract item size from rest capacities of feasible bins\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns items to bins based on a novel score function, which maximizes the score of each bin and minimizes the number of used bins. First, initialize an empty Numpy array \\\"scores\\\" with the same length as \\\"bins\\\" and fill it with zeros. Then, iterate through each bin capacity in \\\"bins\\\" and calculate the score for each bin by dividing the capacity by the item size. Assign the score to the corresponding index in \\\"scores\\\". Finally, return the Numpy array \\\"scores\\\" as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n scores[i] = bins[i] / item\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: In each step, calculate the score for each bin based on its rest capacity. Assign the item to the bin with the highest score and update the rest capacity of that bin. Repeat this process until all items are assigned.\\n\\nStep 1: Initialize an empty Numpy array called 'scores'.\\n\\nStep 2: Calculate the score for each bin by dividing its rest capacity by the maximum capacity among all the bins. Store the scores in the 'scores' array.\\n\\nStep 3: Find the bin with the maximum score.\\n\\nStep 4: If the rest capacity of the bin with the maximum score is equal to the maximum capacity, do not use that bin.\\n\\nStep 5: Assign the item to the bin with the maximum score.\\n\\nStep 6: Update the rest capacity of the assigned bin by subtracting the item size from it.\\n\\nStep 7: Repeat steps 2 to 6 until all items are assigned.\\n\\nStep 8: Return the 'scores' array.\\n\\nCode implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n \\n while item > 0:\\n scores = bins.astype(float) / max_capacity\\n max_score_bin = np.argmax(scores)\\n \\n if bins[max_score_bin] == max_capacity:\\n scores[max_score_bin] = -1\\n \\n if item <= bins[max_score_bin]:\\n bins[max_score_bin] -= item\\n item = 0\\n else:\\n item -= bins[max_score_bin]\\n bins[max_score_bin] = 0\\n\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function takes as input the size of the current item and the rest capacities of the feasible bins, and returns the scores for the bins for assignment. The highest score is given to the bin with the largest rest capacity that is greater than or equal to the size of the item, while bins with maximum capacity are not used. The goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacity = bins\\n scores = np.zeros(len(bins))\\n mask = capacity >= item\\n scores[mask] = capacity[mask] - item + 1\\n scores[~mask] = -np.inf\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the bin index, the inverse of the square root of the residual capacity, and the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * (1 / np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score for each bin based on its characteristics (e.g., residual capacity, index) and using this score to determine the assignment of an item to a bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the logarithm of the bin index, the square of the inverse of the residual capacity, and the square of the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / np.square(np.abs(residual_capacity))) * (1 / np.square(np.abs(residual_capacity - item)))\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score for each bin based on its characteristics (e.g., residual capacity, index) and using this score to determine the assignment of an item to a bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the logarithm of the bin index, the square of the inverse of the residual capacity, and the square of the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.arange(1, len(bins)+1) * (1 / np.abs(residual_capacity)) * (1 / np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a modified score function, where the item is assigned to the bin with the maximum score. The score for each bin is calculated by taking the square of the inverse of the absolute difference between the remaining capacity of the bin and the item size, and then dividing it by the square of the index of the bin. Unused bins are those with a rest capacity equal to the maximum capacity, and the goal is to minimize their number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(\\n bins == max_capacity,\\n 0,\\n np.square(1 / np.abs(bins - item)) / np.square(np.arange(1, len(bins) + 1))\\n )\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score by calculating the score for each bin based on its rest capacity, where the score is equal to the rest capacity raised to the power of inverse item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where the item is assigned to the bin with the maximum score. The score for each bin is calculated by taking the inverse of the absolute difference between the remaining capacity of the bin and the item size, and then dividing it by the index of the bin raised to the power of 3. Unused bins are those with a rest capacity equal to the maximum capacity, and the goal is to minimize their number.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.where(bins == max_capacity, 0, (1 / np.abs(bins - item)) / np.arange(1, len(bins) + 1)**3)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculating the score for each bin by multiplying the logarithm of the item size by the inverse of the absolute difference between the residual capacity and the item size, divided by the index of the bin raised to the power of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log10(item) * (residual_capacity / np.arange(1, len(bins)+1)**2) / np.abs(residual_capacity)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score for each bin based on its characteristics (e.g., residual capacity, index) and using this score to determine the assignment of an item to a bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that takes into account the product of the inverse of the residual capacity of the bin and the inverse of the bin index raised to the power of 5.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = (1 / bins) * (1 / np.arange(1, len(bins) + 1)**5)\\n scores = weights * item\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the remaining capacity of the bin by a weight factor, which is the inverse of the bin index raised to the power of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = 1 / np.arange(len(bins), 0, -1)**2\\n scores = bins * weights\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * np.log(residual_capacity)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the cosine of the square root of the residual capacity, and the inverse of the difference between the bin capacity and the item size raised to the power of 3, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.cos(np.sqrt(residual_capacity)) * (1/np.power(bins - item, 3))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin squared, and the cube root of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)**2) * (np.cbrt(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity squared, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.log(residual_capacity**2)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * np.log(residual_capacity)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the cosine of the square root of the residual capacity, and the inverse of the difference between the bin capacity and the item size raised to the power of 3, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.cos(np.sqrt(residual_capacity)) * (1/np.power(bins - item, 3))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity squared, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.log(residual_capacity**2)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity multiplied by the exponential of the index of the bin, the square root of the absolute difference between the residual capacity and the item size, and the cube of the residual capacity, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) * np.exp(np.arange(1, len(bins)+1)) * np.sqrt(np.abs(residual_capacity - item)) * (residual_capacity**3)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * np.log(residual_capacity)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity squared, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.log(residual_capacity**2)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity multiplied by the exponential of the index of the bin, the square root of the absolute difference between the residual capacity and the item size, and the cube of the residual capacity, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) * np.exp(np.arange(1, len(bins)+1)) * np.sqrt(np.abs(residual_capacity - item)) * (residual_capacity**3)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / (np.abs(residual_capacity - item) + 1))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * np.log(residual_capacity)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"algorithm = The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity multiplied by the exponential of the index of the bin, the square root of the absolute difference between the residual capacity and the item size, and the cube of the residual capacity, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) * np.exp(np.arange(1, len(bins)+1)) * np.sqrt(np.abs(residual_capacity - item)) * (residual_capacity**3)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / (np.abs(residual_capacity - item) + 1))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"algorithm = The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity multiplied by the exponential of the index of the bin, the square root of the absolute difference between the residual capacity and the item size, and the cube of the residual capacity, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) * np.exp(np.arange(1, len(bins)+1)) * np.sqrt(np.abs(residual_capacity - item)) * (residual_capacity**3)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the square root of the product of the index of the bin, the absolute difference between the residual capacity and the item size, and the sum of the residual capacity and item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.sqrt(np.arange(1, len(bins)+1) * np.abs(residual_capacity - item) * (residual_capacity + item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"algorithm = The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity multiplied by the exponential of the index of the bin, the square root of the absolute difference between the residual capacity and the item size, and the cube of the residual capacity, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) * np.exp(np.arange(1, len(bins)+1)) * np.sqrt(np.abs(residual_capacity - item)) * (residual_capacity**3)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"algorithm = The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity multiplied by the exponential of the index of the bin, the square root of the absolute difference between the residual capacity and the item size, and the cube of the residual capacity, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) * np.exp(np.arange(1, len(bins)+1)) * np.sqrt(np.abs(residual_capacity - item)) * (residual_capacity**3)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"algorithm = The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"algorithm = The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.02254,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns items to bins based on a score function that combines the square root of the bin index, the inverse of the residual capacity, and the square of the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (1 / residual_capacity) * (1 / np.square(np.abs(residual_capacity - item)))\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the bin index, the inverse of the square root of the residual capacity, and the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * (1 / np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score for each bin based on its characteristics (e.g., residual capacity, index) and using this score to determine the assignment of an item to a bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the logarithm of the bin index, the square of the inverse of the residual capacity, and the square of the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.arange(1, len(bins)+1) * (1 / np.abs(bins - item + 1e-8)) * (1 / np.abs(bins - item - item + 1e-8))\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score for each bin based on its characteristics (e.g., residual capacity, index) and using this score to determine the assignment of an item to a bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the exponential of the bin index, the cube of the inverse of the residual capacity, and the square root of the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.exp(np.arange(1, len(bins)+1)) * (1 / np.power(np.abs(residual_capacity), 3)) * np.sqrt(1 / np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.03159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score for each bin based on its characteristics (e.g., residual capacity, index) and using this score to determine the assignment of an item to a bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the sum of the logarithm of the bin index, the square of the inverse of the residual capacity, and the square of the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) + (1 / np.abs(residual_capacity + 1e-8))**2 + (1 / np.abs(residual_capacity - item + 1e-8))**2\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that combines the square root of the bin index, the reciprocal of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (1 / residual_capacity) * (1 / np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the logarithm of the bin index, the reciprocal of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / residual_capacity) * (1 / np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"algorithm = The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, and the reciprocal of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on various combinations of the residual capacity, item size, and the index of the bin. \\n\\nMy new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. \\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(bins - item)))\\n scores = (bins - item) * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(bins - item)))\\n scores = (bins - item) * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_26.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cubic root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cubic root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_27.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cubic root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cubic root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_28.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cubic root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cubic root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm (Modified Version of Provided Algorithm): \\n\\nThe new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity multiplied by the index of the bin, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n bin_indices = np.arange(1, len(bins)+1)\\n weights = (residual_capacity / bin_indices) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity * bin_indices) * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_29.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cubic root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cubic root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity))) # changed square root to cube root\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that combines the sum of the logarithm of the bin index, the inverse of the residual capacity raised to the power of 3, and the inverse of the absolute difference between the residual capacity and the item size squared, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n residual_capacity = bins - item\\n scores = np.log(bin_index + 1) + (1 / (residual_capacity + 1e-6))**3 + (1 / np.abs(residual_capacity - item + 1e-6)**2)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.02254,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns items to bins based on a score function that combines the square root of the bin index, the inverse of the residual capacity, and the square of the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.sqrt(np.arange(1, len(bins)+1)) * (1 / residual_capacity) * (1 / np.square(np.abs(residual_capacity - item)))\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the product of the bin index and the inverse of the residual capacity, squared, and the inverse of the absolute difference between the residual capacity and the item size, cubed, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = (np.arange(1, len(bins)+1) * (1 / residual_capacity)**2) * (1 / np.abs(residual_capacity - item)**3)\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the bin index, the inverse of the square root of the residual capacity, and the inverse of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * (1 / np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.02928,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_30.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cubic root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cubic root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_31.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cubic root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cubic root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_32.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cubic root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cubic root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item))))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_33.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_34.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines a logarithmic transformation, the square root of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = np.sqrt(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_35.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines a logarithmic transformation, the square root of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = np.sqrt(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_36.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines a logarithmic transformation, the square root of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = np.sqrt(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_37.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines a logarithmic transformation, the square root of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = np.sqrt(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_38.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines a logarithmic transformation, the square root of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = np.sqrt(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_39.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.sqrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines a logarithmic transformation, the square root of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = np.sqrt(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the provided algorithm. It assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithmic function of the bin index, the inverse of the residual capacity, and the exponential function of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / residual_capacity) * np.exp(-np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that combines the sum of the logarithm of the bin index, the inverse of the residual capacity raised to the power of 3, and the inverse of the absolute difference between the residual capacity and the item size squared, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n residual_capacity = bins - item\\n scores = np.log(bin_index + 1) + (1 / (residual_capacity + 1e-6))**3 + (1 / np.abs(residual_capacity - item + 1e-6)**2)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.log(np.abs(residual_capacity))) # changed cube root to logarithm\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.02254,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_40.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for assigning items to bins based on the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nNew algorithm: My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the natural logarithm of the residual capacity, the reciprocal of the absolute difference between the residual capacity and the item size, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.abs(residual_capacity - item)) * np.log(np.abs(residual_capacity - item))\\n scores = residual_capacity * np.log(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = (residual_capacity * weights) + np.exp(-np.square(residual_capacity - item))\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the cube root of the logarithm of the residual capacity divided by the sum of the index of the bin and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.cbrt(np.log(residual_capacity)) / (np.arange(1, len(bins)+1) + np.cbrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the square root of the logarithm of the bin size divided by the sum of the index of the bin and the square root of the absolute difference between the bin size and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_size = bins - item\\n weights = np.sqrt(np.log(bin_size)) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(bin_size - item)))\\n scores = bin_size * weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n1. Calculate the residual capacity of each bin by subtracting the item size from the rest capacities of feasible bins.\\n2. Calculate the weights for each bin by dividing the logarithm of the residual capacity by the product of the index of the bin and the square root of the absolute difference between the residual capacity and the item size.\\n3. Calculate the scores for each bin by multiplying the residual capacity by the weights.\\n4. Return the scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.sqrt(np.abs(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines a logarithmic transformation, the square root of the residual capacity divided by the sum of the index of the bin and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) + np.sqrt(np.abs(residual_capacity - item)))\\n scores = np.sqrt(residual_capacity) * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the sum of the indices of the bins and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.cumsum(np.arange(1, len(bins)+1)) + np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity divided by the product of the index of the bin and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = np.log(residual_capacity) / (np.arange(1, len(bins)+1) * np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the provided algorithm. It assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithmic function of the bin index, the inverse of the residual capacity, and the exponential function of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / residual_capacity) * np.exp(-np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that combines the sum of the logarithm of the bin index, the inverse of the residual capacity raised to the power of 3, and the inverse of the absolute difference between the residual capacity and the item size squared, while minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins))\\n residual_capacity = bins - item\\n scores = np.log(bin_index + 1) + (1 / (residual_capacity + 1e-6))**3 + (1 / np.abs(residual_capacity - item + 1e-6)**2)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.log(np.abs(residual_capacity))) # changed cube root to logarithm\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the square root of the product of the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(residual_capacity * item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the provided algorithm. It assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithmic function of the bin index, the inverse of the residual capacity, and the exponential function of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.arange(1, len(bins)+1) * (1 / residual_capacity) * np.exp(-np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithmic function of the bin index, the inverse of the residual capacity squared, and the exponential function of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / residual_capacity ** 2) * np.exp(-np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.log(np.abs(residual_capacity))) # changed cube root to logarithm\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the square root of the product of the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(residual_capacity * item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the provided algorithm. It assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithmic function of the bin index, the inverse of the residual capacity, and the exponential function of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.arange(1, len(bins)+1) * (1 / residual_capacity) * np.exp(-np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the logarithmic function of the bin index, the inverse of the residual capacity squared, and the exponential function of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n scores = np.log(np.arange(1, len(bins)+1)) * (1 / residual_capacity ** 2) * np.exp(-np.abs(residual_capacity - item))\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * np.log(residual_capacity)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the square root of the product of the residual capacity and the item size, while minimizing the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(residual_capacity * item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the provided algorithm. It assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for assigning items to bins based on a combination of the residual capacity of the bin, the index of the bin, and various mathematical functions applied to the residual capacity and the item size.\\n\\nMy new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the square root of the logarithm of the residual capacity, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity - item))) * np.sqrt(np.log(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin, and the cube root of the square of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.square(residual_capacity - item)))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, and the logarithm of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins. In this new algorithm, the residual capacity is adjusted by a factor that depends on the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.log(np.abs(residual_capacity))\\n adjusted_residual_capacity = residual_capacity * np.exp(-np.arange(1, len(bins)+1) * 0.1)\\n scores = adjusted_residual_capacity * weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the logarithm of the index of the bin, and the cube root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (1 / np.arange(1, len(bins)+1)) * (1 / np.cbrt(np.abs(residual_capacity)))\\n scores = residual_capacity * np.log(np.arange(1, len(bins)+1)) * weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the logarithm of the residual capacity, and the square root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity))) * np.log(residual_capacity)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assign items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the fourth root of the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * (1 / np.sqrt(np.abs(residual_capacity)))**(1/4)\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the index of the bin, the cosine of the square root of the residual capacity, and the inverse of the difference between the bin capacity and the item size raised to the power of 3, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.arange(1, len(bins)+1)) * np.cos(np.sqrt(residual_capacity)) * (1/np.power(bins - item, 3))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the logarithm of the residual capacity of the bin, the index of the bin squared, and the cube root of the difference between the residual capacity and the item size, while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (np.log(residual_capacity) / np.arange(1, len(bins)+1)**2) * (np.cbrt(residual_capacity - item))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that combines the residual capacity of the bin, the square root of the index of the bin, and the absolute difference between the residual capacity and the item size, while minimizing the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacity = bins - item\\n weights = (residual_capacity / np.sqrt(np.arange(1, len(bins)+1))) * (1 / np.abs(residual_capacity))\\n scores = residual_capacity * weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm is designed to assign an item to a bin by using a novel score function, with the goal of minimizing the number of used bins. The main steps of the algorithm are as follows:\\n- Calculate the ratio between the item size and the rest capacities of the bins.\\n- Assign a score to each bin based on its ratio value.\\n- If a bin has a maximum capacity, assign a score of -1 to it.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = np.where(bins == np.max(bins), -1, ratios)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm assigns an item to the bin with the maximum score at each step, considering that if a bin has its rest capacity equal to the maximum capacity, it should not be used, and the goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_capacities = np.copy(bins)\\n utilization = bin_capacities < np.max(bin_capacities)\\n scores = np.zeros_like(bin_capacities)\\n scores[utilization] = np.maximum(0, item - bin_capacities[utilization])\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm Steps:\\n1. Calculate the remaining capacity ratio for each bin by dividing the rest capacity of each bin by the maximum capacity.\\n2. Calculate the score for each bin by multiplying the remaining capacity ratio with the inverse of the bin index.\\n3. Set the score of bins with remaining capacity equal to the maximum capacity to 0.\\n4. Return the scores array.\\n\\nPython Implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_ratio = bins / max_capacity\\n scores = remaining_ratio * (1 / np.arange(1, len(bins) + 1))\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, where the score is calculated by multiplying the inverse of the remaining capacity of each bin by the size of the item, and for bins with capacity equal to the maximum, the score is set to zero. Finally, the function returns the array of scores for each bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = item * (1 / (bins[bins != max_capacity] - item))\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the scores for each bin by dividing the rest capacity of each bin by the item size and taking the floor value, and then setting the score of a bin to 0 if its rest capacity equals the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.floor(bins / item)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score for each step, taking into account the rest capacity of each bin; the main steps are: calculate the scores for each bin based on the rest capacity, select the bin with the maximum score that is not equal to the maximum capacity, update the scores by reducing the score of the selected bin and increasing the rest capacity, repeat the previous steps until all items have been assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n rest_capacity = bins - item\\n max_capacity = np.max(bins)\\n\\n while item > 0:\\n max_score = np.max(scores)\\n max_index = np.argmax(scores)\\n \\n if rest_capacity[max_index] != max_capacity:\\n scores[max_index] -= 1\\n rest_capacity[max_index] += item\\n item -= 1\\n\\n return scores\",\n \"objective\": 0.07928,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm: \\nThe algorithm assigns a score to each bin based on two main criteria: the rest capacity of the bin and the difference between the rest capacity and the item size. The maximum score is given to the bin with the highest rest capacity, and the score decreases as the rest capacity decreases or as the difference between the rest capacity and the item size increases. If a bin has rest capacity equal to the maximum capacity, its score is set to zero to ensure it is not used.\\n\\nMain steps:\\n1. Initialize an empty Numpy array named \\\"scores\\\" with the same length as the \\\"bins\\\" array.\\n2. Find the maximum rest capacity using the Numpy \\\"max\\\" function.\\n3. Calculate the difference between the rest capacity and the item size for each bin using the Numpy \\\"subtract\\\" function.\\n4. Calculate the scores for each bin using the Numpy \\\"exp\\\" function, giving higher scores to bins with higher rest capacity and lower differences.\\n5. Set the scores of bins with rest capacity equal to the maximum capacity to zero using the Numpy \\\"where\\\" function.\\n6. Return the \\\"scores\\\" array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores = np.exp(bins - (max_capacity - item))\\n scores = np.where(bins == max_capacity, 0, scores)\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, considering the rest capacity of the bin, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins == item] += 1\\n scores[bins > item] += bins[bins > item] % item\\n scores[bins < item] -= 1\\n return scores\",\n \"objective\": 0.23986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score, taking into account the rest capacities of the bins. The score for each bin is calculated based on the bin's remaining capacity and the number of used bins is minimized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins - item\\n scores = np.where(capacities > 0, capacities, -np.inf)\\n remaining_bins = np.count_nonzero(scores > -np.inf)\\n max_capacity = np.max(capacities)\\n max_ind = np.argmax(scores)\\n scores[max_ind] = -np.inf if max_capacity == bins[max_ind] else -np.inf\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated based on its rest capacity divided by the maximum capacity among all bins. The steps are as follows:\\n 1. Calculate the maximum capacity among all bins.\\n 2. Calculate the scores for each bin by dividing its rest capacity by the maximum capacity.\\n 3. Assign the item to the bin with the maximum score.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins / max_capacity\\n scores[item] = -np.inf\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the item size and the rest capacities of the bins. If a bin has a maximum capacity, it is assigned a score of -1. If the rest capacity of a bin is less than the item size, it is assigned a score of -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where((bins == np.max(bins)) | (bins < item), -1, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of its remaining capacity and a penalty factor, with a larger penalty applied to bins with higher remaining capacity, in order to encourage the assignment of items to bins with less remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.exp(bins / max_capacity) - 1\\n scores = bins * penalty\\n scores = scores / np.arange(1, len(bins) + 1)\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns a score to each bin based on the sum of the item size and the rest capacities of the bins, multiplied by the inverse of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_capacities = bins + item\\n scores = sum_capacities * (1 / np.arange(1, len(bins) + 1))\\n scores[bins < item] -= item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The algorithms assign a score to each bin based on its capacity or ratio of capacity and use this score to determine the bin that an item should be assigned to.\\n\\nNew Algorithm Description: My new algorithm assigns a score to each bin based on the sum of the inverse of its capacity and the inverse of its index, with a penalty applied to bins with the maximum capacity, in order to minimize the number of used bins.\\n\\nPython Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (1 / bins) + (1 / np.arange(1, len(bins) + 1))\\n scores[bins == max_capacity] -= 1\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins / (np.arange(1, len(bins) + 1) * np.max(bins))) - (bins == np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.arange(1, len(bins) + 1) * np.max(bins))) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the sum of the item size and the rest capacities of the bins, divided by the square root of the index plus one, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nHere's the Python implementation of the new score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_capacities = bins + item\\n scores = sum_capacities / np.sqrt(np.arange(1, len(bins) + 1) + 1)\\n scores[bins < item] -= item\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the absolute difference between its capacity and the double of the item size, multiplied by the inverse of its index, with a penalty applied to bins with the maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (np.abs(bins - (2 * item))) * (1 / np.arange(1, len(bins) + 1))\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: scores = (bins / (np.arange(1, len(bins) + 1)) + np.sqrt(bins) / item) - (bins == np.max(bins))\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.arange(1, len(bins) + 1)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins / (np.arange(1, len(bins) + 1) * np.max(bins))) - (bins == np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the square of its remaining capacity and the inverse of its index, with a penalty applied to bins with the maximum capacity, in order to minimize the number of used bins.\\n\\nPython Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins ** 2) * (1 / np.arange(1, len(bins) + 1))\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04558,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / (bins - item)**np.arange(1, num_bins + 1) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index plus one, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 1) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the square root of its index, with an additional penalty term to promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.sqrt(np.arange(1, num_bins+1))\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate scores for each bin based on the item size, remaining capacity of the bin, and the bin index.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by a logarithm of its index, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins+1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, np.log(bin_index)) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the cube root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nHere is the implementation of the new score function in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.power(range(1, len(bins) + 1), 1/3)))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = np.power(ratios, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the item size to a function of the remaining capacity of the bin and its index.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by the logarithm of its index, with the bin capacity multiplied to ensure self-consistency and performance.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (np.power(bins - item, np.log(np.arange(1, len(bins) + 1) + 1)) * bins)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / (bins - item)**np.arange(1, num_bins + 1) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index plus one, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 1) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The new algorithm uses a different parameter setting for the score function, where the power factor for the remaining bin capacity is squared.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1)**2)\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the square root of its index, with an additional penalty term to promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.sqrt(np.arange(1, num_bins+1))\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate scores for each bin based on the item size, remaining capacity of the bin, and the bin index.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by a logarithm of its index, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins+1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, np.log(bin_index)) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the cube root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nHere is the implementation of the new score function in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.power(range(1, len(bins) + 1), 1/3)))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = np.power(ratios, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 3) + np.sqrt(np.power(bins, 4) - item**4)) * bin_weights\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an added logarithm term and a penalty term that increases with smaller capacities, aimed at minimizing the number of used bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) * np.log(bins + 1)) + (1 / np.power(bin_index, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on a combination of the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, and the logarithm of the remaining capacity of the bin, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) * np.log(bins)) * bin_weights\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the square root of the item size to the product of the remaining capacity of the bin raised to the power of its index, with a penalty term that increases with smaller capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / np.power(bins - item, np.arange(1, len(bins) + 1)) + 1 / np.arange(1, len(bins) + 1)**2\\n return scores\",\n \"objective\": 0.0331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / (bins - item)**np.arange(1, num_bins + 1) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index plus one, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = 1 / np.sum(bins)\\n scores = item / (np.power(bins - item, bin_index + 1) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index plus one, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 2) + np.sqrt(np.power(bins, 3) - item**3)) * bin_weights\\n return scores\",\n \"objective\": 0.03431,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the cube root of its index, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins+1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) + np.cbrt(np.power(bins, 3) - item**3)) * bin_weights\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = np.array([(1 - bin_capacity / total_capacity) for bin_capacity in bins])\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 4) + np.sin(np.power(bins, 5) - item**5)) * bin_weights\\n return scores\",\n \"objective\": 0.02415,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = np.ones(num_bins)\\n scores = item / (np.power(bins - item, bin_index + 3) + np.sqrt(np.power(bins, 4) - item**4)) * bin_weights\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the sine of the power determined by its index, with an added exponential term and a penalty term that increases exponentially with smaller capacities, aimed at minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) * np.exp(np.sin(bin_index))) + np.exp(bin_weights / np.power(bin_index, 2))\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an added logarithm term and a penalty term that increases with smaller capacities, aimed at minimizing the number of used bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) * np.log(bins + 1)) + (1 / np.power(bin_index, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on a combination of the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, and the logarithm of the remaining capacity of the bin, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item/(np.power(bins - item, np.arange(1, num_bins + 1)) * np.log(bins)) * bin_weights\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the square root of the item size to the product of the remaining capacity of the bin raised to the power of its index, with a penalty term that increases with smaller capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / np.power(bins - item, np.arange(1, len(bins) + 1)) + 1 / np.arange(1, len(bins) + 1)**2\\n return scores\",\n \"objective\": 0.0331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / (bins - item)**np.arange(1, num_bins + 1) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 4) + np.sin(np.power(bins, 5) - item**5)) * bin_weights\\n return scores\",\n \"objective\": 0.02415,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the inverse of the difference between the item size and the remaining capacity of the bin, raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = np.ones(num_bins)\\n scores = 1 / (np.power(bins - item, bin_index + 3) + np.sqrt(np.power(bins, 4) - item**4)) * bin_weights\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the sine of the power determined by its index, with an added exponential term and a penalty term that increases exponentially with smaller capacities, aimed at minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) * np.exp(np.sin(bin_index))) + np.exp(bin_weights / np.power(bin_index, 2))\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an added logarithm term and a penalty term that increases with smaller capacities, aimed at minimizing the number of used bins.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) * np.log(bins + 1)) + (1 / np.power(bin_index, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on a combination of the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, and the logarithm of the remaining capacity of the bin, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item/(np.power(bins - item, np.arange(1, num_bins + 1)) * np.log(bins)) * bin_weights\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the square root of the item size to the product of the remaining capacity of the bin raised to the power of its index, with a penalty term that increases with smaller capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / np.power(bins - item, np.arange(1, len(bins) + 1)) + 1 / np.arange(1, len(bins) + 1)**2\\n return scores\",\n \"objective\": 0.0331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / (bins - item)**np.arange(1, num_bins + 1) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n max_capacity = np.max(bins)\\n penalty_term = (max_capacity - bins) * np.power(bin_index, 0.5)\\n scores = item * np.log(bins) ** bin_index / (bins - item) + penalty_term\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.mean(bins))\\n scores = item / (item - bins) + np.log(np.mean(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the exponential of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.exp(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 4) + np.sin(np.power(bins, 5) - item**5)) * bin_weights\\n return scores\",\n \"objective\": 0.02415,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the inverse of the difference between the item size and the remaining capacity of the bin, raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = np.ones(num_bins)\\n scores = 1 / (np.power(bins - item, bin_index + 3) + np.sqrt(np.power(bins, 4) - item**4)) * bin_weights\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the sine of the power determined by its index, with an added exponential term and a penalty term that increases exponentially with smaller capacities, aimed at minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index) * np.exp(np.sin(bin_index))) + np.exp(bin_weights / np.power(bin_index, 2))\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an added term that exponentially increases the score for bins with larger capacities, aimed at minimizing the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index)) * np.exp(bin_weights) + (1 / np.power(bin_index, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the square root of the item size multiplied by the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = np.sqrt(item) * (np.log(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.log(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.median(bins))\\n scores = item / (item - bins) + np.log(np.median(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.mean(bins))\\n scores = item / (item - bins) + np.log(np.mean(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the exponential of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.exp(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 4) + np.sin(np.power(bins, 5) - item**5)) * bin_weights\\n return scores\",\n \"objective\": 0.02415,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the inverse of the difference between the item size and the remaining capacity of the bin, raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = np.ones(num_bins)\\n scores = 1 / (np.power(bins - item, bin_index + 3) + np.sqrt(np.power(bins, 4) - item**4)) * bin_weights\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the product of the square root of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (np.sqrt(item) * np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 3)) * bin_weights\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the square root of the item size multiplied by the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = np.sqrt(item) * (np.log(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.log(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.median(bins))\\n scores = item / (item - bins) + np.log(np.median(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.mean(bins))\\n scores = item / (item - bins) + np.log(np.mean(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the exponential of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.exp(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the exponential of the item size divided by the sum of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = np.exp(item / np.sum(bins) ** np.arange(1, num_bins + 1)) / (bins - item) + (1 / (np.arange(1, num_bins + 1) + 1) ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with an additional penalty term to promote performance and minimize the number of used bins, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, bin_index + 4) + np.sin(np.power(bins, 5) - item**5)) * bin_weights\\n return scores\",\n \"objective\": 0.02415,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the product of the item size and the remaining capacity of the bin, raised to the power determined by the index of the bin, with a penalty term that promotes performance and minimizes the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (np.log(item * bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the product of the square root of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (np.sqrt(item) * np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 3)) * bin_weights\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the square root of the item size multiplied by the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = np.sqrt(item) * (np.log(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.log(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.median(bins))\\n scores = item / (item - bins) + np.log(np.median(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.mean(bins))\\n scores = item / (item - bins) + np.log(np.mean(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the exponential of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.exp(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the cube root of the item size and the exponential of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (np.cbrt(item) * (np.exp(bins) ** bin_index)) / (bins - item) + (1 / np.power(bin_index + 1, 3)) * bin_weights\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the product of the item size and the remaining capacity of the bin, raised to the power determined by the index of the bin, with a penalty term that promotes performance and minimizes the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = np.ones(num_bins) * 0.5\\n scores = (np.log(item * bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: \\nAssigning scores to each bin based on the characteristics of both the item and the remaining capacity of the bin, with additional penalty terms to optimize performance and minimize the number of used bins.\\n\\nNew algorithm description:\\nThe new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\\n\\nPython implementation of the new score function:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (item * np.sqrt(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the square root of the item size multiplied by the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = np.sqrt(item) * (np.log(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.log(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(Identify top) The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 10\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights) * 10\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning scores to each bin based on the characteristics of both the item and the remaining capacity of the bin, with additional penalty terms to optimize performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the natural logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation of the new score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (item * (np.log(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights) * 100\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.median(bins))\\n scores = item / (item - bins) + np.log(np.median(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.mean(bins))\\n scores = item / (item - bins) + np.log(np.mean(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the item size and the rest capacities of the bins. If a bin has a maximum capacity, it is assigned a score of -1. If the rest capacity of a bin is less than the item size, it is assigned a score of -1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins < item, -1, item / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with larger capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.maximum(bins - item, np.zeros_like(bins))\\n penalty = np.exp(-remaining_capacity)\\n scores = item / (remaining_capacity * np.arange(1, len(bins) + 1)) * penalty\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of its remaining capacity and a penalty factor, with a larger penalty applied to bins with higher remaining capacity, in order to encourage the assignment of items to bins with less remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.exp(bins / max_capacity) - 1\\n scores = bins * penalty\\n scores = scores / np.arange(1, len(bins) + 1)\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns a score to each bin based on the remaining capacity of the bin, with a penalty factor applied based on a function of the ratio between the remaining capacity and the maximum capacity, in order to encourage the assignment of items to bins with less remaining capacity. The score is further adjusted based on the position of the bin in the list, with earlier bins having higher scores. Bins with the maximum capacity have their scores reduced by the size of the item.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = bins / max_capacity\\n scores = bins * (1 - np.exp(-ratios)**2)\\n scores = scores / np.arange(1, len(bins) + 1)\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns a score to each bin based on the sum of the item size and the rest capacities of the bins, multiplied by the inverse of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_capacities = bins + item\\n scores = sum_capacities * (1 / np.arange(1, len(bins) + 1))\\n scores[bins < item] -= item\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the remaining capacity of the bin and the maximum capacity, with a penalty factor applied to bins with higher ratios and a bonus factor applied to bins with lower ratios, in order to encourage the assignment of items to bins with less remaining capacity and to make use of bins with larger capacities efficiently.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = bins / max_capacity\\n scores = bins * (1 - np.exp(-ratios)**2)\\n scores = scores / (np.arange(1, len(bins) + 1) + 1) + (max_capacity - bins) * item / max_capacity\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns a score to each bin based on the sum of the item size and the rest capacities of the bins, multiplied by the inverse of its index, with a higher penalty applied to bins with larger capacities, in order to prioritize bins with smaller capacities for assignment, thereby minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_capacities = bins + item\\n scores = sum_capacities * (1 / np.arange(1, len(bins) + 1))\\n scores[bins > item] -= item\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns a score to each bin based on the sum of the item size and the rest capacities of the bins, multiplied by the inverse of its index, with a higher penalty applied to bins with larger capacities, in order to prioritize bins with smaller capacities for assignment, thereby minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_item = item / np.max(bins) # Normalize item size\\n normalized_bins = bins / np.max(bins) # Normalize bin sizes\\n sum_capacities = normalized_bins + normalized_item\\n scores = sum_capacities * (1 / np.arange(1, len(bins) + 1))\\n scores[normalized_bins > normalized_item] -= normalized_item\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n bonus_penalties = np.arange(num_bins, 0, -1) / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the product of the item size and the remaining capacity of the bin, raised to the power determined by the index of the bin, with a penalty term that promotes performance and minimizes the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = np.ones(num_bins) * 0.5\\n scores = (np.log(item * bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = 1 / bins\\n scores = item * (np.sqrt(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the square root of the item size multiplied by the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = np.sqrt(item) * (np.log(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.log(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = 1 / bins\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(Identify top) The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 10\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights) * 10\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning scores to each bin based on the characteristics of both the item and the remaining capacity of the bin, with additional penalty terms to optimize performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the natural logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation of the new score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = (item * (np.log(bins) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights) * 100\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size divided by the exponential of the squared difference between the item size and the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, considering both the remaining capacity of all bins and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.median(bins))\\n scores = item / (item - bins) + np.log(np.median(bins)) / np.log(item + 1) * bin_weights\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the square root of the product of the item size and the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, and divided by the square root of the item size. The formula is implemented within a loop to calculate scores for each bin, and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = np.sqrt(item * bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / (np.sqrt(item))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the sum of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalty_terms = (bins.max() - bins) * bin_index / num_bins - np.sqrt(item)\\n scores = (item + np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms) * 100\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.sqrt(bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / num_bins\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and then multiplied by a constant factor of 50. The penalty terms are calculated as the sum of the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, subtracted by the square root of the item size.\\n\\nPython implementation of the new score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalty_terms = (bins.max() - bins) * bin_index / num_bins - np.sqrt(item)\\n scores = (item * np.log(bins) ** bin_index / (bins - item) + penalty_terms) * 50\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the square root of the item size and the natural logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the reciprocal of the bin index divided by the square of the bin capacity, and the final scores are multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = np.sqrt(item) * np.log(bins) ** bin_index / (bins - item) + (1 / (bin_index * np.power(bins, 2))) * 100\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins) * 10\\n scores = (np.log(bins + 1) ** bin_index / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights) * 10\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin.\\n\\nPython implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.log(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nThe new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = 1 / bins\\n scores = item * (np.log(bins + 1) ** bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the product of the item size and the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, and divided by the logarithm of the item size. The formula is implemented within a loop to calculate scores for each bin, and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = np.log(item * bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / (np.log(item))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the sum of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalty_terms = (bins.max() - bins) * bin_index / num_bins - np.sqrt(item)\\n scores = (item + np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms) * 100\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign a score to each bin based on the product of the item size and a function of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the sum of the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, subtracted by the cube root of the item size.\\n\\nPython implementation of the new score function:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalty_terms = - np.cbrt(item)\\n scores = (item * np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms) * 50\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.sqrt(bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / num_bins\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the square root of the item size and the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, divided by the square root of the item size, and scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin, and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalty_terms = (bins.max() - bins) * bin_index / np.sqrt(item)\\n scores = np.sqrt(item) * np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and then multiplied by a constant factor of 50. The penalty terms are calculated as the sum of the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, subtracted by the square root of the item size.\\n\\nPython implementation of the new score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalty_terms = (bins.max() - bins) * bin_index / num_bins - np.sqrt(item)\\n scores = (item * np.log(bins) ** bin_index / (bins - item) + penalty_terms) * 50\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the square root of the item size and the natural logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the reciprocal of the bin index divided by the square of the bin capacity, and the final scores are multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = np.sqrt(item) * np.log(bins) ** bin_index / (bins - item) + (1 / (bin_index * np.power(bins, 2))) * 100\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins) * 10\\n scores = (np.log(bins + 1) ** bin_index / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights) * 10\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the product of the item size and the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, and divided by the logarithm of the item size. The formula is implemented within a loop to calculate scores for each bin, and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = np.log(item * bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / (np.log(item))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the sum of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalty_terms = (bins.max() - bins) * bin_index / num_bins - np.sqrt(item)\\n scores = (item + np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms) * 100\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign a score to each bin based on the product of the item size and a function of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the sum of the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, subtracted by the cube root of the item size.\\n\\nPython implementation of the new score function:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalty_terms = - item / 10\\n scores = (item * np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms) * 50\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the logarithm of the item size multiplied by the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalty_terms = np.ones_like(bins) * 0.5 # Simplified penalty term\\n scores = (np.log(item) * np.log(bins) ** bin_index / (bins - item) + penalty_terms) * 100\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins, and finally multiplied by a constant factor of 20.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins)\\n scores = np.power(np.sqrt(bins), bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.sqrt(bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / num_bins\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the square root of the item size and the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, divided by the square root of the item size, and scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin, and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = np.sqrt(item) * np.sqrt(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the sum of the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, subtracted by the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalty_terms = - np.sqrt(item)\\n scores = (item * np.log(bins) ** bin_index / (bins - item) + penalty_terms) * 50\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the product of the item size and the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, and divided by the logarithm of the item size. The formula is implemented within a loop to calculate scores for each bin, and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = np.log(item * bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / (np.log(item))\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms assign a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with additional penalty terms to promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the sum of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins)\\n penalty_terms = (bins.max() - bins) * bin_index / num_bins\\n scores = (np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms) * 100\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign a score to each bin based on the product of the item size and a function of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the sum of the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, subtracted by the cube root of the item size.\\n\\nPython implementation of the new score function:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalty_terms = - item / 10\\n scores = (item * np.sqrt(bins) ** bin_index / (bins - item) + penalty_terms) * 50\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the logarithm of the item size multiplied by the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with additional penalty terms that promote performance and minimize the number of used bins, and finally multiplied by a constant factor of 100.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalty_terms = np.ones_like(bins) * 0.5 # Simplified penalty term\\n scores = (np.log(item) * np.log(bins) ** bin_index / (bins - item) + penalty_terms) * 100\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins, and finally multiplied by a constant factor of 20.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n bin_weights = (1 - bins)\\n scores = np.power(np.sqrt(bins), bin_index) / (bins - item) + (1 / np.power(bin_index + 1, 2)) * bin_weights\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the square root of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n scores = item * np.sqrt(bins) ** bin_index / (bins - item) - (bins.max() - bins) * bin_index / num_bins\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the square root of the item size and the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the difference between the maximum capacity of the bins and the remaining capacity, divided by the square root of the item size, and scaled by a factor determined by the index of the bin. The formula is implemented within a loop to calculate scores for each bin, and the scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(1, len(bins) + 1)\\n scores = np.sqrt(item) * np.sqrt(bins) ** bin_index / (bins - item)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the item size and the logarithm of the remaining capacity of the bin, raised to the power determined by its index, with an additional penalty term that promotes performance and minimizes the number of used bins. The penalty term is calculated as the sum of the difference between the maximum capacity of the bins and the remaining capacity, scaled by a factor determined by the index of the bin, subtracted by the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalty_terms = - np.sqrt(item)\\n scores = (item * np.log(bins) ** bin_index / (bins - item) + penalty_terms) * 50\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity + std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is further modified by multiplying the penalties with the logarithm of the item size and the maximum bin capacity, aiming to prioritize bins with larger capacity and penalize for larger item sizes. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n total_remaining_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_remaining_capacity)\\n penalties = (1 / bins) ** bin_index * np.log(item) * np.log(max_bin_capacity)\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity - std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n scores = np.where(np.isnan(scores), 0, scores)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm modifies the scoring function by introducing a penalty term based on the logarithm of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / (np.log(bins)+1)) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm modifies the scoring function by introducing a penalty term based on the logarithm of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / (np.log(bins)+1)) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity + std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is further modified by multiplying the penalties with the square root of the item size and the maximum bin capacity, aiming to prioritize bins with larger capacity and penalize for larger item sizes.\\n\\nHere is the implementation of the new algorithm in a function named \\\"score\\\":\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n bin_weights = (1 - bins / np.sum(bins))\\n penalties = (1 / bins) ** bin_index * np.sqrt(item) * np.sqrt(max_bin_capacity)\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_26.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity + std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a bonus for bins with larger capacities and a penalty for bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by multiplying the penalties with the logarithm of the item size and the maximum bin capacity, aiming to prioritize bins with larger capacity and penalize for larger item sizes.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n total_remaining_capacity = np.sum(bins)\\n bin_weights = (bins / total_remaining_capacity)\\n penalties = (1 / bins) ** bin_index * np.log(item) * np.log(max_bin_capacity)\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity - std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n scores = np.where(np.isnan(scores), 0, scores)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index. This score is then further modified by applying penalties or bonuses based on certain factors such as total remaining capacity, maximum bin capacity, logarithm of the item size, and scaling factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with larger remaining capacities and a penalty term applied based on the logarithm of the item size and the maximum bin capacity.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n total_remaining_capacity = np.sum(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 2\\n penalties = (1 / bins) ** bin_index * np.log(item) * np.log(max_bin_capacity)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with larger remaining capacities and a penalty term applied based on the logarithm of the item size and the maximum bin capacity, as well as the difference between the current item size and each bin's remaining capacity, with different parameter settings.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n total_remaining_capacity = np.sum(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 3\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(item) * np.log(max_bin_capacity / 2) * np.abs(bins - item) ** 2\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_27.json", "content": "[\n {\n \"algorithm\": \"(New Algorithm Description): The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the logarithm of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew Algorithm Implementation:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity + std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty for bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaled penalty term to the ratio, which is calculated based on the logarithm of the item size and the maximum bin capacity, aiming to prioritize bins with larger capacity and penalize for larger item sizes.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (np.log(item) * np.log(max_bin_capacity)) * penalties\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity - std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n scores = np.where(np.isnan(scores), 0, scores)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The common backbone idea in the provided algorithms is to calculate a score for each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index.\\n\\nNew Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, and applies penalty terms based on the logarithm of the item size and the maximum bin capacity, with a scaling factor to prioritize bins with larger remaining capacities.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.sum(bins) / max_bin_capacity) ** 2\\n penalties = (1 / bins) ** bin_index * np.log(item) * np.log(max_bin_capacity)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_28.json", "content": "[\n {\n \"algorithm\": \"(New Algorithm Description): The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the logarithm of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew Algorithm Implementation:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity + std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = bonus_penalties * (item / ((bins - item) * scaled_penalties))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty for bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaled penalty term to the ratio, which is calculated based on the logarithm of the item size and the maximum bin capacity, aiming to prioritize bins with larger capacity and penalize for larger item sizes.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (np.log(item) * np.log(max_bin_capacity)) * penalties\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity - std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n scores = np.where(np.isnan(scores), 0, scores)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n total_remaining_capacity = np.sum(bins)\\n penalties = (1 / bins) ** bin_index * np.log(total_remaining_capacity)\\n scores = item / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_29.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(New Algorithm Description): The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the logarithm of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew Algorithm Implementation:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity + std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = bonus_penalties * (item / ((bins - item) * scaled_penalties))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty for bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaled penalty term to the ratio, which is calculated based on the logarithm of the item size and the maximum bin capacity, aiming to prioritize bins with larger capacity and penalize for larger item sizes.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (np.log(item) * np.log(max_bin_capacity)) * penalties\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity - std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n scores = np.where(np.isnan(scores), 0, scores)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (total_remaining_capacity / max_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the square of the item size divided by the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one, the bin capacity, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item**2 / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * 10)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity of the bin multiplied by a penalty factor determined by the bin index and the maximum capacity, with a higher penalty applied to bins with larger capacities. The penalty factor is calculated using a power function with a base of 2 and an exponent of the bin index minus 1 divided by the maximum capacity minus 1, to ensure that smaller bins have a higher penalty and larger bins have a lower penalty, in order to optimize the bin assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = item / bins\\n penalties = np.power(2, (np.arange(1, len(bins) + 1) - 1) / (max_capacity - 1))\\n scores = ratios * penalties\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the ratio of the item size to the rest capacity of the bin and a penalty factor determined by the bin index and the maximum capacity, with a higher penalty applied to bins with larger capacities, in order to optimize the bin assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = item / bins\\n penalties = np.exp(-np.arange(1, len(bins) + 1) / max_capacity)\\n scores = ratios * penalties\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of its remaining capacity and a penalty factor, with a larger penalty applied to bins with higher remaining capacity, in order to encourage the assignment of items to bins with less remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.exp(bins / max_capacity) - 1\\n scores = bins * penalty\\n scores = scores / np.arange(1, len(bins) + 1)\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the difference of the remaining capacity of the bin and the item size, with a higher penalty applied to bins with larger indices, in order to minimize the number of used bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (np.maximum(bins - item, 1) * np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns a score to each bin based on the remaining capacity of the bin, with a penalty factor applied based on a function of the ratio between the remaining capacity and the maximum capacity, in order to encourage the assignment of items to bins with less remaining capacity. The score is further adjusted based on the position of the bin in the list, with earlier bins having higher scores. Bins with the maximum capacity have their scores reduced by the size of the item.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = bins / max_capacity\\n scores = bins * (1 - np.exp(-ratios)**2)\\n scores = scores / np.arange(1, len(bins) + 1)\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the remaining capacity of the bin, with a penalty factor applied based on a function of the ratio between the remaining capacity and the maximum capacity, in order to encourage the assignment of items to bins with less remaining capacity. The score is further adjusted based on the position of the bin in the list, with earlier bins having higher scores. Bins with the maximum capacity have their scores reduced by the size of the item, and an additional penalty factor is applied based on the ratio between the item size and the remaining capacity of the bin.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = bins / max_capacity\\n scores = bins * (1 - np.exp(-ratios)**2)\\n scores = scores / np.arange(1, len(bins) + 1)\\n scores[bins == max_capacity] -= item\\n scores -= item / bins\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_30.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(New Algorithm Description): The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the logarithm of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew Algorithm Implementation:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns scores to bins based on a weighted combination of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with penalty terms applied based on the maximum bin capacity and the total remaining capacity of all bins, and a scaling factor applied to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n total_remaining_capacity = np.sum(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity) * (1 / (total_remaining_capacity - bins + 1))\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity + std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = bonus_penalties * (item / ((bins - item) * scaled_penalties))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty for bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaled penalty term to the ratio, which is calculated based on the logarithm of the item size and the maximum bin capacity, aiming to prioritize bins with larger capacity and penalize for larger item sizes.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (np.log(item) * np.log(max_bin_capacity)) * penalties\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity - std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n scores = np.where(np.isnan(scores), 0, scores)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_31.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(New Algorithm Description): The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the logarithm of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew Algorithm Implementation:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns scores to bins based on a weighted combination of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with penalty terms applied based on the maximum bin capacity and the total remaining capacity of all bins, and a scaling factor applied to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n total_remaining_capacity = np.sum(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity) * (1 / (total_remaining_capacity - bins + 1))\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = bonus_penalties * (item / ((bins - item) * scaled_penalties))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n mean_bin_capacity = np.mean(bins)\\n std_bin_capacity = np.std(bins)\\n scaling_factor = ((mean_bin_capacity - std_bin_capacity) / mean_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights\\n scores = np.where(np.isnan(scores), 0, scores)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins. The scoring function is modified by adding a scaling factor to the penalties calculated based on the ratio of the total remaining capacity to the maximum bin capacity, aiming to prioritize bins with larger remaining capacities. \\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n total_remaining_capacity = np.sum(bins)\\n max_bin_capacity = np.max(bins)\\n scaling_factor = total_remaining_capacity / max_bin_capacity\\n scaled_penalties = penalties * scaling_factor\\n scores = item / ((bins - item) * scaled_penalties) * bin_weights * bonus_penalties\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_32.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = bonus_penalties * (item / ((bins - item) * scaled_penalties))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the item size, the remaining capacity of the bin, and the index of the bin, with a penalty term applied based on the ratio of the remaining capacity to the maximum bin capacity, aiming to minimize the number of used bins and prioritize bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins)) + 1\\n penalties = (1 / (bins + 1)) ** bin_index\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (penalties * bins) / max_bin_capacity\\n scores = item / ((bins - item) * scaled_penalties) * (bins / max_bin_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** (bin_weights)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_33.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bonus_penalties = 1\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = bonus_penalties * (item / ((bins - item) * scaled_penalties))\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the item size, the remaining capacity of the bin, and the index of the bin, with a penalty term applied based on the ratio of the remaining capacity to the maximum bin capacity, aiming to minimize the number of used bins and prioritize bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins)) + 1\\n penalties = (1 / (bins + 1)) ** bin_index\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (penalties * bins) / max_bin_capacity\\n scores = item / ((bins - item) * scaled_penalties) * (bins / max_bin_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by introducing a penalty term based on the inverse of the remaining capacity of each bin, with a scaling factor applied to prioritize bins with smaller remaining capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = item / ((bins - item) * penalties) * bin_weights\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms assign scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to a certain power, with penalties and bonuses applied to different bins based on their capacities.\\n\\nNew Algorithm Description: The new algorithm assigns scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by the exponential function of its index, with a scaling factor applied to prioritize bins with larger remaining capacities, in order to minimize the number of used bins.\\n\\nNew Algorithm Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = 1 / num_bins\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n max_bin_capacity = np.max(bins)\\n scaling_factor = (np.exp(np.sum(penalties)) * max_bin_capacity) ** 2\\n scores = item / ((bins - item) * penalties) * bin_weights * scaling_factor\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_34.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = np.log(item) / ((bins - item) * scaled_penalties)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the item size, the remaining capacity of the bin, and the index of the bin, with a penalty term applied based on the ratio of the remaining capacity to the maximum bin capacity, aiming to minimize the number of used bins and prioritize bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins)) + 1\\n penalties = (1 / (bins + 1)) ** bin_index\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (penalties * bins) / max_bin_capacity\\n scores = item / ((bins - item) * scaled_penalties) * (bins / max_bin_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n penalties = (1 / bins) ** bin_indices\\n scores = item / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_35.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = np.log(item) / ((bins - item) * scaled_penalties)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the item size, the remaining capacity of the bin, and the index of the bin, with a penalty term applied based on the ratio of the remaining capacity to the maximum bin capacity, aiming to minimize the number of used bins and prioritize bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_index = np.arange(len(bins)) + 1\\n penalties = (1 / (bins + 1)) ** bin_index\\n max_bin_capacity = np.max(bins)\\n scaled_penalties = (penalties * bins) / max_bin_capacity\\n scores = item / ((bins - item) * scaled_penalties) * (bins / max_bin_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item + 1) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_36.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = np.log(item) / ((bins - item) * scaled_penalties)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = (item / ((bins - item) * penalties)) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item + 1) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_37.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = np.log(item) / ((bins - item) * scaled_penalties)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = 1\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_weights = np.ones(num_bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2) * bin_weights\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item + 1) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_38.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = np.log(item) / ((bins - item) * scaled_penalties)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = 1\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item + 1) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_39.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = np.log(item) / ((bins - item) * scaled_penalties)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = 1\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm: The new algorithm assigns a score to each bin based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item + 1) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = np.log(item) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the inverse of the difference between the item size and the rest capacity of the bin, divided by the index plus one, the bin capacity, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nHere's the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (1 / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the difference between the item size and the rest capacity of the bin, the square root of the index plus one, and the bin capacity, with a higher penalty applied to bins with smaller capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff * np.sqrt(np.arange(1, len(bins) + 1) + 1) * bins))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the sum of the item size divided by the square of the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one, the bin capacity, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2)) / ((np.arange(1, len(bins) + 1) + 1) * bins * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * 10)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity of the bin multiplied by a penalty factor determined by the bin index and the maximum capacity, with a higher penalty applied to bins with larger capacities. The penalty factor is calculated using a power function with a base of 2 and an exponent of the bin index minus 1 divided by the maximum capacity minus 1, to ensure that smaller bins have a higher penalty and larger bins have a lower penalty, in order to optimize the bin assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = item / bins\\n penalties = np.power(2, (np.arange(1, len(bins) + 1) - 1) / (max_capacity - 1))\\n scores = ratios * penalties\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the ratio of the item size to the rest capacity of the bin and a penalty factor determined by the bin index and the maximum capacity, with a higher penalty applied to bins with larger capacities, in order to optimize the bin assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = item / bins\\n penalties = np.exp(-np.arange(1, len(bins) + 1) / max_capacity)\\n scores = ratios * penalties\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_bins = bins / np.max(bins)\\n scores = item / ((normalized_bins - item) * range(1, len(normalized_bins) + 1))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of its remaining capacity and a penalty factor, with a larger penalty applied to bins with higher remaining capacity, in order to encourage the assignment of items to bins with less remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.exp(bins / max_capacity) - 1\\n scores = bins * penalty\\n scores = scores / np.arange(1, len(bins) + 1)\\n scores[bins == max_capacity] -= item\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_40.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** (bin_index + 1) * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the combination of the item size and the remaining capacity of the bin, with additional terms designed to prioritize bins with smaller remaining capacities, and penalize large remaining capacities. The algorithm takes into account the maximum capacity of the bins and applies a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_indices = np.arange(num_bins) + 1\\n max_bin_capacity = np.max(bins)\\n penalties = (1 / bins) ** bin_indices * np.log(max_bin_capacity)\\n scaling_factor = np.prod(penalties) / np.mean(penalties)\\n scores = item / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a penalty term applied based on the inverse of the maximum bin capacity to prioritize bins with smaller remaining capacities, and a scaling factor applied to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins + 1)\\n penalties = (1 / bins) ** bin_index\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = np.log(item) / ((bins - item) * penalties) * scaling_factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n avg_bin_capacity = np.mean(bins)\\n std_capacity = np.std(bins)\\n scaling_factor = ((avg_bin_capacity + std_capacity) / avg_bin_capacity) ** 2\\n scaled_penalties = penalties * scaling_factor\\n scores = np.log(item) / ((bins - item) * scaled_penalties)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = np.sum(penalties) / np.mean(penalties)\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the square of the product of the item size and the remaining capacity of the bin, with penalties based on the inverse of the bin capacity and a scaling factor to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scaling_factor = 1\\n scores = (item * bins) ** 2 / (penalties * (bins - item)) * scaling_factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the provided algorithms, the common backbone idea is to assign scores to bins based on the item size and the remaining capacity of the bin, with penalties and bonuses applied to prioritize certain bins and minimize the number of used bins.\\n\\nThe new algorithm assigns scores to bins based on the square root of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with penalties for smaller capacities and bonuses for larger capacities, aiming to minimize the number of used bins and considering the total remaining capacity of all bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.sqrt(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = np.power(1 / bins, np.arange(1, num_bins + 1))\\n scores = np.log(item + 1) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a ratio involving the item size, remaining capacity of the bin, and a penalty factor.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the logarithm of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with an additional penalty term proportional to the standard deviation of bin capacities and a scaling factor to maintain self-consistency.\\n\\nNew algorithm implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** (np.arange(1, num_bins + 1))\\n scores = np.log(item) / ((bins - item) * penalties)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the item size divided by the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities and a bonus for bins with larger capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n penalties = (1 / bins) ** np.arange(1, num_bins + 1)\\n bin_indices = np.arange(num_bins) + 1\\n scores = np.log(item) / ((bins - item) * penalties) * (bin_indices ** 2)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the inverse of the difference between the item size and the rest capacity of the bin, divided by the index plus one, the bin capacity, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nHere's the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (1 / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity and a function of the index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the function of the index\\n index_function = np.sqrt(np.log(np.arange(1, len(bins) + 1) + 1))\\n\\n # Calculate the scores for each bin\\n scores = item / ((bins - item) * index_function)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the difference between the item size and the rest capacity of the bin, the logarithm of the index plus one, and the square of the bin capacity, with a higher penalty applied to bins with smaller capacities.\\n\\nNew Algorithm Code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff * np.log(np.arange(1, len(bins) + 1) + 1) * bins**2))\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the difference between the item size and the rest capacity of the bin, the square root of the index plus one, and the bin capacity, with a higher penalty applied to bins with smaller capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff * np.sqrt(np.arange(1, len(bins) + 1) + 1) * bins))\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the sum of the item size divided by the square of the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one, the bin capacity, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2)) / ((np.arange(1, len(bins) + 1) + 1) * bins * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the difference between the item size and the rest capacity of the bin, the cube root of the index plus one, and the square of the bin capacity, with a higher penalty applied to bins with smaller capacities.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff * np.cbrt(np.arange(1, len(bins) + 1) + 1) * bins**2))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * 10)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity of the bin multiplied by a penalty factor determined by the bin index and the maximum capacity, with a higher penalty applied to bins with larger capacities. The penalty factor is calculated using a power function with a base of 2 and an exponent of the bin index minus 1 divided by the maximum capacity minus 1, to ensure that smaller bins have a higher penalty and larger bins have a lower penalty, in order to optimize the bin assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = item / bins\\n penalties = np.power(2, (np.arange(1, len(bins) + 1) - 1) / (max_capacity - 1))\\n scores = ratios * penalties\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm assigns a score to each bin based on the ratio of the item size squared to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the square of the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item**2 / diff) / (((np.arange(1, len(bins) + 1) + 1) * bins)**2)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity and a function of the index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the function of the index\\n index_function = np.sqrt(np.log(np.arange(1, len(bins) + 1) + 1))\\n\\n # Calculate the scores for each bin\\n scores = item / ((bins - item) * index_function)\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the square root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.sqrt(range(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the product of the remaining capacity of the bin, the cube of the bin index, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities and larger indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = item / ((bins - item) * np.cbrt(np.arange(1, len(bins) + 1)) * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the difference between the item size and the rest capacity of the bin, the square root of the index plus one, and the cube of the bin capacity, with a higher penalty applied to bins with larger capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff * np.sqrt(np.arange(1, len(bins) + 1) + 1) * bins**3))\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the difference between the item size and the rest capacity of the bin, the cube root of the index plus one, and the square of the bin capacity, with a higher penalty applied to bins with smaller capacities.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff * np.cbrt(np.arange(1, len(bins) + 1) + 1) * bins**2))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * 10)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / np.power(bins - item, np.arange(1, num_bins + 1)) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms assign a score to each bin based on the ratio of the item size to some function of the difference between the item size and the rest capacity of the bin, and the bin capacity.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the difference between the item size and the rest capacity of the bin, the index plus one, and the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities.\\n\\nNew algorithm code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n \\n # Calculate the scores for each bin\\n scores = (item / (diff * (np.arange(len(bins)) + 1) * bins))\\n \\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm assigns a score to each bin based on the ratio of the item size squared to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the square of the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item**2 / diff) / (((np.arange(1, len(bins) + 1) + 1) * bins)**2)\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: The algorithm calculates the scores for each bin based on the ratio of the item size to the square of the remaining capacity of the bin, multiplied by the logarithm of the bin index plus 1, with higher penalties applied to bins with smaller capacities and larger indices.\\n\\nHere's the implementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = item / ((bins - item) ** 2 * np.log(np.arange(1, len(bins) + 1) + 1))\\n\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the square root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.sqrt(range(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the product of the remaining capacity of the bin, the cube of the bin index, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities and larger indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = item / ((bins - item) * np.cbrt(np.arange(1, len(bins) + 1)) * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / np.power(bins - item, np.arange(1, num_bins + 1)) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the cube root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nHere is the implementation of the new score function in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.power(range(1, len(bins) + 1), 1/3)))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = np.power(ratios, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the item size to a function of the remaining capacity of the bin and its index.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by the logarithm of its index, with the bin capacity multiplied to ensure self-consistency and performance.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (np.power(bins - item, np.log(np.arange(1, len(bins) + 1) + 1)) * bins)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the square root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.sqrt(range(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to the product of the remaining capacity of the bin, the cube of the bin index, and the square root of the bin capacity, with a higher penalty applied to bins with smaller capacities and larger indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores for each bin\\n scores = item / ((bins - item) * np.cbrt(np.arange(1, len(bins) + 1)) * np.sqrt(bins))\\n\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the absolute difference between the item size and the rest capacity of the bin, divided by the index plus one and the bin capacity, with a higher penalty applied to bins with smaller capacities, in order to efficiently utilize bins with larger capacities.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / diff) / ((np.arange(1, len(bins) + 1) + 1) * bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/10run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the square of the difference between the item size and the rest capacity of the bin, the bin index plus one raised to the power of its index, multiplied by the bin capacity, with a higher penalty applied to bins with larger capacities, in order to utilize bins with smaller capacities. \\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the absolute difference between item size and rest capacities of bins\\n diff = np.abs(item - bins)\\n\\n # Calculate the scores for each bin\\n scores = (item / (diff**2 * (np.arange(len(bins)) + 1)**np.arange(len(bins)))) * bins\\n \\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins. The algorithm also takes into consideration the total remaining capacity of all bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n total_capacity = np.sum(bins)\\n bin_weights = (1 - bins / total_capacity)\\n scores = item / np.power(bins - item, np.arange(1, num_bins + 1)) * bin_weights\\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / np.power(bins - item, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate scores for each bin based on the item size, remaining capacity of the bin, and the bin index.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to the power determined by a logarithm of its index, with an additional penalty term to promote performance and minimize the number of used bins.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n bin_index = np.arange(1, num_bins+1)\\n bin_weights = (1 - bins / np.sum(bins))\\n scores = item / (np.power(bins - item, np.log(bin_index)) + np.sqrt(np.power(bins, 2) - item**2)) * bin_weights\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity and adjust the scores based on various factors such as the item size and the position of the bin in the list.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * range(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the cube root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nHere is the implementation of the new score function in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.power(range(1, len(bins) + 1), 1/3)))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by its index, with a balanced penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = np.power(ratios, np.arange(1, len(bins) + 1))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the item size to a function of the remaining capacity of the bin and its index.\\n\\nNew algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by the logarithm of its index, with the bin capacity multiplied to ensure self-consistency and performance.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / (np.power(bins - item, np.log(np.arange(1, len(bins) + 1) + 1)) * bins)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin and the square root of its index, with a higher penalty applied to bins with smaller capacities, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) * (np.sqrt(range(1, len(bins) + 1))))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the ratio of the item size to the product of the remaining capacity of the bin raised to a power determined by the logarithm of its index, with the bin capacity squared and multiplied by a constant factor of 10 to ensure self-consistency and promote performance.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / ((bins - item) ** (np.log(np.arange(1, len(bins) + 1) + 1)) * bins ** 2 * 10)\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where the scores are calculated by dividing the remaining capacity by the item size and subtracting a factor based on the ratio of the remaining capacity to the maximum capacity, weighted by the cube of the index in the bins array, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n ratio = remaining_capacity / max_capacity \\n score = int(bins[i] / item) - ratio**3 * i**2 \\n scores[i] = max(score, 0) \\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign scores to each bin based on its remaining capacity compared to the item size.\\n\\nMy new algorithm: Assign scores to each bin based on the bin capacity and the item size, using a square root function to amplify the difference between smaller and larger capacities, while considering the inverse of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.sqrt(max_capacity - bins[i] + 1) / (1/item)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n \\n max_capacity = np.max(bins) # Maximum capacity of the bins\\n \\n # Calculate the score for each bin based on their rest capacity\\n scores[bins != max_capacity] = item * (max_capacity - bins[bins != max_capacity]) / (max_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on its remaining capacity compared to the item size, with the goal of minimizing the number of used bins.\\n\\nNew algorithm: \\nAssign scores to each bin based on the bin capacity and the item size, using a logarithmic function to amplify the difference between smaller and larger capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.log(max_capacity - bins[i] + 1)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their remaining capacity, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a quadratic formula involving the ratio of the capacity to the maximum capacity and the square of the index in the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - ratio**2 * i # Calculate the score based on division, ratio, and the square of the index\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity still have a score of zero, but bins with smaller capacities have higher scores according to a different formula.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] >= max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - bins[i]) / item\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic formula. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins < max_capacity] = np.log(max_capacity - bins[bins < max_capacity] - item + 1)\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their remaining capacity, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic formula involving the ratio of the capacity to the maximum capacity and the logarithm of the index in the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - np.log(i+1) * ratio # Calculate the score based on division, ratio, and the logarithm of the index\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with smaller capacities have higher scores based on a certain formula, and bins with the maximum capacity have a score of zero. In each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n score = (1.0 / (max_capacity - bins[i])) * (bins[i] - item + 1) # Calculate the score based on a certain formula\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04608,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n scores = np.nan_to_num(scores, posinf=0, neginf=0)\\n return scores\",\n \"objective\": 0.0488,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the rest capacity of each bin and the size of the current item. It calculates the scores by multiplying the rest capacity of each bin by a coefficient derived from the ratio between the rest capacity and the item size, and assigns the calculated scores to the corresponding bins in the scores array. It also takes into account the maximum capacity of a bin to ensure it is not used if its rest capacity equals the maximum capacity.\\n\\nNew score function implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n item_size = item\\n max_capacity = np.max(bins)\\n \\n scores = (bins * (bins - item_size) / (max_capacity * item_size)).astype(int)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.05111,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms assign scores to each bin based on the remaining capacity of the bin, taking into account factors such as the ratio of the remaining capacity to the maximum capacity and the index of the bin in the bins array.\\n\\nNew algorithm description: My new algorithm assigns scores to each bin based on a complex formula involving the remaining capacity of the bin, the ratio of the remaining capacity to the maximum capacity, and a quadratic function of the index in the bins array, all combined using a trigonometric function.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n ratio = remaining_capacity / max_capacity \\n index_factor = math.sin(math.radians(i)) # Apply a trigonometric function to the index\\n score = int(bins[i] / item) - ratio**2 * index_factor # Calculate the score based on division, ratio, and the index factor\\n scores[i] = max(score, 0) \\n\\n return scores\",\n \"objective\": 0.05353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm iterates over the rest capacities of bins, and assigns a score based on the following criteria: if the capacity equals the maximum capacity, the score is set to 0; otherwise, the score is calculated by dividing the capacity by the item size and subtracting a factor based on the ratio of the capacity to the maximum capacity, weighted by the square of the index in the bins array. The function then returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - ratio**2 # Calculate the score based on division and ratio\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.05685,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the cosine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * cos(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm squared of the square root of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.9.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(np.sqrt(bins - item)))**2)) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.9)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.1, the square of the number of times the bin has been used, the sine of the item size, and cosine of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.1) + (np.arange(len(bins)) ** 2) + np.sin(item) + (np.cos(item) / 0.5)\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.3, the square of the number of times the bin has been used, the tangent of the item size, and the square root of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(bins - item)) * np.log(item) + (np.exp(item) * 0.3) + (np.arange(len(bins)) ** 2) + np.tan(item) + (np.sqrt(item) / 0.5)\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is determined by taking the sum of the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item))) ** np.log(bins) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using various mathematical functions.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential of the item size raised to the power of the difference between the bin's capacity and the item size, plus the natural logarithm of the item size multiplied by a constant factor of 0.5, and divided by the sum of the cosine of the bin's current capacity and the tangent of the item size, all multiplied by the constant factor of 0.7, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins * (1/np.sqrt(bins - item))) * (np.exp(item) ** (bins - item)) + (np.log(item) * 0.5) / (np.cos(bins) + np.tan(item)) * 0.7 * (1/bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the cube of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 3) + (np.sqrt(item) / (bins - item)) + ((1 / item) * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(0.5 * np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** (0.5 * np.log(bins - item))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 2\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(max_capacity - item))) * (item * (max_capacity - item)) + (np.arange(len(bins)) ** 2) + (item / (np.sqrt(bins - item) + 1e-7)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.8.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.8)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the sum of the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins + item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the product between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins * item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using various mathematical functions.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential of the item size raised to the power of the difference between the bin's capacity and the item size, plus the natural logarithm of the item size multiplied by a constant factor of 0.5, and divided by the sum of the cosine of the bin's current capacity and the tangent of the item size, all multiplied by the constant factor of 0.7, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins * (1/np.sqrt(bins - item))) * (np.exp(item) ** (bins - item)) + (np.log(item) * 0.5) / (np.cos(bins) + np.tan(item)) * 0.7 * (1/bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the cube of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 3) + (np.sqrt(item) / (bins - item)) + ((1 / item) * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the exponential function raised to the power of the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the log of the bin's current capacity, plus the square root of the number of times the bin has been used, the log of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the exponential function raised to the power of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.exp(np.log(np.sqrt(bins - item))))) * (np.log(bins) ** np.arange(len(bins))) + (np.sqrt(np.arange(len(bins)))) + (np.log(item) / (bins - item)) + ((item / bins) ** np.exp(bins - item))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 2\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(max_capacity - item))) * (item * (max_capacity - item)) + (np.arange(len(bins)) ** 2) + (item / (np.sqrt(bins - item) + 1e-7)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square root of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the reciprocal of the current item size multiplied by the bin's current capacity raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item * (bins - item))) * np.exp(np.log(bins) * np.arange(len(bins))) + np.sqrt(np.arange(len(bins))) + (np.sqrt(item) / (bins - item)) + (1 / item * bins) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nCalculate the score for each bin as the product of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the product between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins * item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity divided by the item size, and raised to the power of the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) * item)) ** (np.log(bins) / item) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the cube of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 3) + (np.sqrt(item) / (bins - item)) + ((1 / item) * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity, plus the exponential function raised to the power of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the square root of the product of the item size and the inverse of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (np.log(bins) ** np.arange(len(bins))) + (np.exp(np.arange(len(bins)))) + (np.log(item) / (bins - item)) + (np.sqrt(item * (1 / bins)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 0.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(max_capacity - item))) * (item * (max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / (np.sqrt(bins - item) + 1e-7)) + np.exp(item) * 0.5\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square root of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the reciprocal of the current item size multiplied by the bin's current capacity raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item * (bins - item))) * np.exp(np.log(bins) * np.arange(len(bins))) + np.sqrt(np.arange(len(bins))) + (np.sqrt(item) / (bins - item)) + (1 / item * bins) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the sum of the square root of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3) * np.sqrt((bins - item) + (bins - item) ** 2))) ** (bins / np.log(item)) * np.exp(item * (bins - item)) / ((1 / bins) * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nCalculate the score for each bin as the product of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm_description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, subtracted by the cube root of the number of times the bin has been used, the difference between the bin's capacity and the item size divided by the square root of the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) ** 0.5)) * np.exp(np.log(bins) * np.arange(len(bins))) - ((np.arange(len(bins))) ** (1/3)) + ((bins - item) / np.sqrt(item)) + ((1 / item) * (1 / bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm_description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, subtracted by the cube root of the number of times the bin has been used, the difference between the bin's capacity and the item size divided by the square root of the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) ** 0.5)) * np.exp(np.log(bins) * np.arange(len(bins))) - ((np.arange(len(bins))) ** (1/3)) + ((bins - item) / np.sqrt(item)) + ((1 / item) * (1 / bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the natural logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity and divided by the square root of the item size to prioritize bins with higher capacities.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / item) * np.exp(item * (bins - item))\\n scores *= (1 / bins) / np.sqrt(item)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm_description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, subtracted by the cube root of the number of times the bin has been used, the difference between the bin's capacity and the item size divided by the square root of the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) ** 0.5)) * np.exp(np.log(bins) * np.arange(len(bins))) - ((np.arange(len(bins))) ** (1/3)) + ((bins - item) / np.sqrt(item)) + ((1 / item) * (1 / bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(np.log(bins) * np.arange(len(bins)))) / (np.sqrt(bins - item) * np.log(item) * np.exp(item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the logarithm of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\nPython implementation of the new algorithm: \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) / (np.log(bins) * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(np.log(bins) * np.arange(len(bins)))) / (np.sqrt(bins - item) * np.log(item) * np.exp(item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the logarithm of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(bins - item)) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (np.log(bins) * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate the score for each bin based on the bin's current capacity and the difference between the bin's capacity and the item size, utilizing various mathematical operations and functions.\\n\\nNew algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product between the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item * (bins - item))) ** np.log(bins) * np.exp(item * (bins - item)) * np.log(item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nThe new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores = scores / (1 / bins * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) * np.sqrt(item)\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(np.log(bins) * np.arange(len(bins)))) / (np.sqrt(bins - item) * np.log(item) * np.exp(item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities, and finally multiplied by the square root of the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate the score for each bin based on the bin's current capacity and the difference between the bin's capacity and the item size, utilizing various mathematical operations and functions.\\n\\nNew algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product between the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item * (bins - item))) ** np.log(bins) * np.exp(item * (bins - item)) * np.log(item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the rest capacity of the bin divided by the difference between the bin's capacity and the item size, plus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, (bins - item)) + (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the sum of the bin's remaining capacity and the item size divided by the bin's remaining capacity minus the item size, while also taking into account the logarithm of the item size and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + math.log(item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = bins[i] / (bins[i] - item + 1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = (bins[i] / (bins[i] - item + 1)) + (1/item) * (i+1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where the scores are calculated by dividing the remaining capacity by the item size and subtracting a factor based on the ratio of the remaining capacity to the maximum capacity, weighted by the cube of the index in the bins array, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n ratio = remaining_capacity / max_capacity \\n score = int(bins[i] / item) - ratio**3 * i**2 \\n scores[i] = max(score, 0) \\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign scores to each bin based on its remaining capacity compared to the item size.\\n\\nMy new algorithm: Assign scores to each bin based on the bin capacity and the item size, using a square root function to amplify the difference between smaller and larger capacities, while considering the inverse of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.sqrt(max_capacity - bins[i] + 1) / (1/item)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the bin capacity and the item size, using a logarithmic function to amplify the difference between smaller and larger capacities, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.log(max_capacity - bins[i] + 1) / (1/item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign scores to each bin based on its remaining capacity compared to the item size.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and a factor that increases with the number of times the bin has been used, while incorporating a square root function to emphasize the impact of remaining capacity on the score.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n log_item = math.log(item)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n index_factor = math.sqrt(i + 1) # Apply square root to the index\\n score = remaining_capacity * log_item + index_factor * (bins[i] // item)\\n scores[i] = max(score, 0)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n \\n max_capacity = np.max(bins) # Maximum capacity of the bins\\n \\n # Calculate the score for each bin based on their rest capacity\\n scores[bins != max_capacity] = item * (max_capacity - bins[bins != max_capacity]) / (max_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic formula. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins < max_capacity] = max_capacity - bins[bins < max_capacity] - item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and the number of times the bin has been used. This algorithm aims to minimize the number of used bins by prioritizing bins with larger remaining capacities, smaller item sizes, and fewer previous uses.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * bins / (bins - item + np.arange(len(bins)))) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on its remaining capacity compared to the item size, with the goal of minimizing the number of used bins.\\n\\nNew algorithm: \\nAssign scores to each bin based on the bin capacity and the item size, using a logarithmic function to amplify the difference between smaller and larger capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.log(max_capacity - bins[i] + 1)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on their remaining capacity, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a quadratic formula involving the ratio of the capacity to the maximum capacity, the square of the index in the bins array, and a constant value k.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n k = 2\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - ratio**2 * i - k # Calculate the score based on division, ratio, the square of the index, and the constant value k\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) * np.sqrt(item)\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the natural logarithm of the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity squared to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.sqrt(item)) ** (bins / (bins - item)) * np.log(np.exp(item * (bins - item)))) / (bins ** 2)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) * np.arange(len(bins))) / (np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities, and finally multiplied by the square root of the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate the score for each bin based on the bin's current capacity and the difference between the bin's capacity and the item size, utilizing various mathematical operations and functions.\\n\\nNew algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product between the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item * (bins - item))) ** np.log(bins) * np.exp(item * (bins - item)) * np.log(item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The algorithm calculates the score for each bin as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size, and finally multiplied by the reciprocal of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) ** bins * np.exp(item * (bins - item)) / ((1 / bins) * np.sqrt(item)) * (1 / item)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the difference between the bin's capacity and the item size, plus the number of times the bin has been used squared, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a factor that takes into account the square of the difference between the bin's capacity and the item size, while also applying a logarithmic function to promote performance.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (np.sqrt(bins - item) ** 2) + np.log10(np.exp(item))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log((bins - item) * (bins - item))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: Assign scores to each bin based on the bin's current capacity multiplied by the item size divided by the log value of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.log(bins - item) ** 2) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, item size, the number of times the bin has been used, and a certain function that incorporates the item size and promotes performance.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / (bins - item + 1)) + np.exp(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) // (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the rest capacity of the bin divided by the difference between the bin's capacity and the item size, plus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, (bins - item)) + (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-10 # Small value to avoid division by zero\\n \\n scores = bins / (bins - item) + np.sqrt(bins) / np.sqrt(bins - item) + np.arange(len(bins))\\n \\n # Set scores of bins with rest capacity equals maximum capacity to negative infinity\\n scores[bins == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on its remaining capacity, item size, and the number of times it has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a logarithmically decreasing function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n \\n max_capacity = np.max(bins) # Maximum capacity of the bins\\n \\n # Calculate the score for each bin based on remaining capacity, item size, number of uses, and logarithmic function\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = item / (bins[i] - item + 1) + np.log(item) / (np.log(bins[i] + 1) * (i + 1))\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus a constant factor multiplied by the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the sum of the logarithm of the bin's current capacity and the item size divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.log(bins + item) / np.sqrt(bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = bins[i] / (bins[i] - item + 1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = (bins[i] / (bins[i] - item + 1)) + (1/item) * (i+1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) + np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on a combination of the bin's capacity, the item size, and the number of times the bin has been used. It also incorporates a logarithmic function to further promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** 2)) * np.log(1 + np.arange(len(bins))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's capacity, the item size, and the average of the rest capacities of the feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_rest_capacity = np.mean(bins)\\n scores = bins / ((bins - item) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) * avg_rest_capacity\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a factor that takes into account the square of the difference between the bin's capacity and the item size, while also applying a logarithmic function to promote performance.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (np.sqrt(bins - item) ** 2) + np.log10(np.exp(item))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the item size, the logarithm of the bin's capacity divided by the logarithm of the item size, and the exponential of the number of times the bin has been used, while also applying a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / np.sqrt(item)) + (np.log(bins) / np.log(item)) + np.exp(item) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size plus the number of times the bin has been used, and also multiplies it by the logarithm of the item size to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins)) * np.log(item)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log((bins - item) * (bins - item))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity, the item size, the logarithm of the difference between the bin's capacity and the item size, and the square of the number of times the bin has been used. It then applies a power function to promote performance and returns the scores for the bins.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.log(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms assign scores to the bins based on a combination of the bin's current capacity, the item size, the difference between the bin's capacity and the item size, the logarithm and square root of this difference, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size, an additional term incorporating the reciprocal of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log((bins - item) * np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item) + (1 / item) + (0.5 * (bins / item))\\n return scores\",\n \"objective\": 0.02324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm and main steps: \\nThe new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance. \\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log((bins - item) * np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: Assign scores to each bin based on the bin's current capacity multiplied by the item size divided by the log value of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.log(bins - item) ** 2) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the bin's current capacity multiplied by the item size divided by the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and take the exponential of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2)\\n scores = np.exp(scores) \\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the difference between the bin's capacity and the item size, and the cube of the number of times the bin has been used, while also applying a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (bins / (bins - item)) + (np.arange(len(bins)) ** 3)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, item size, the number of times the bin has been used, and a certain function that incorporates the item size and promotes performance.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / (bins - item + 1)) + np.exp(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the difference between the bin's capacity and the item size, and the cube of the number of times the bin has been used, while also applying a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (bins / (bins - item)) + (np.ones(len(bins)) * 100)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's current capacity, the item size, and the number of times the bin has been used. Additionally, various mathematical operations such as square root, logarithm, and exponential functions are applied to these values to promote performance.\\n\\nBased on this backbone idea, the new algorithm assigns scores to each bin by taking the square root of the bin's current capacity multiplied by the item size, and then dividing it by the logarithm of the square of the difference between the bin's capacity and the item size, all while considering the number of times the bin has been used and applying an exponential function for performance promotion.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins * item) / (np.log((bins - item) ** 2))\\n scores += np.arange(len(bins)) + np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt((bins - item) * np.log(np.sqrt(bins - item))))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used, multiplied by a constant factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + 2 * np.sqrt(np.arange(len(bins)))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the reciprocal of the item size times the logarithm of the bin's capacity, and the cube of the item size divided by the difference between the bin's capacity and the item size, while also applying a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((1 / item) * np.log(bins)) + ((item ** 3) / (bins - item))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a larger remaining capacity ratio. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size minus the sum of the first and last digits of the item size, the reciprocal of the item size, an additional term incorporating the reciprocal of the square root of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size plus the square root of the item size.\\n\\nPython code for the new algorithm:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) * np.sqrt(bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item - int(str(item)[0]) - int(str(item)[-1])) + (1 / item) + ((1 / np.sqrt(item)) / item) + (0.5 * (bins / item + np.sqrt(item)))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size, multiplied by the number of times the bin has been used squared divided by the item size, added to a constant factor multiplied by the item size divided by the bin's current capacity, and finally applying a power function to promote performance by adding the exponential of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) * ((np.arange(len(bins)) ** 2) / item) + (0.3 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's capacity, the item size, and the average of the rest capacities of the feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_rest_capacity = np.mean(bins)\\n scores = bins / ((bins - item) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) * avg_rest_capacity\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a factor that takes into account the square of the difference between the bin's capacity and the item size, while also applying a logarithmic function to promote performance.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (np.sqrt(bins - item) ** 2) + np.log10(np.exp(item))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity divided by the logarithm of the item size, plus the exponential of the number of times the bin has been used and a power function to promote performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (np.log(bins) / np.log(item)) + np.exp(item) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size plus the number of times the bin has been used, and also multiplies it by the logarithm of the item size to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins)) * np.log(item)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.square(bins) * np.log(bins)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt((bins - item) * np.log(np.sqrt(bins - item))))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the provided algorithms, the common backbone idea is to calculate scores based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.5.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.sqrt(bins) / (bins - item)) * np.log(bins)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item)) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / ((bins - item) * np.log(bins / np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's current capacity squared divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used divided by the item size, and the square root of the item size multiplied by the logarithm of the bin's capacity, and apply a power function to promote performance.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 2) / ((np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (np.sqrt(item) * np.log(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the product of the bins and the item.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the reciprocal of the item size times the logarithm of the bin's capacity, and the cube of the item size divided by the difference between the bin's capacity and the item size, while also applying a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((1 / item) * np.log(bins)) + ((item ** 3) / (bins - item))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a larger remaining capacity ratio. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size minus the sum of the first and last digits of the item size, the reciprocal of the item size, an additional term incorporating the reciprocal of the square root of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size plus the square root of the item size.\\n\\nPython code for the new algorithm:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) * np.sqrt(bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item - int(str(item)[0]) - int(str(item)[-1])) + (1 / item) + ((1 / np.sqrt(item)) / item) + (0.5 * (bins / item + np.sqrt(item)))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a smaller remaining capacity ratio.\\n\\nNew code implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = 1 - bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it introduces a term incorporating the reciprocal of the item size, the product of the bin's remaining capacity ratio and the square root of the difference between the bin's capacity and the item size, and the exponential of the item size. \\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity_ratio = bins / np.max(bins)\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (1 / item) * (remaining_capacity_ratio * np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and the logarithm of the product of the bin's capacity and the item size, divided by the square root of the sum of the squares of the bin sizes, multiplied by a constant factor and added to a power function that incorporates the size of the current item and promotes performance.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.log(bins * item) / np.sqrt(np.sum(bins ** 2)) + (0.5 * (item / bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size, multiplied by the number of times the bin has been used squared divided by the item size, added to a constant factor multiplied by the item size divided by the bin's current capacity, and finally applying a power function to promote performance by adding the exponential of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) * ((np.arange(len(bins)) ** 2) / item) + (0.3 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's capacity, the item size, and the average of the rest capacities of the feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_rest_capacity = np.mean(bins)\\n scores = bins / ((bins - item) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) * avg_rest_capacity\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.square(bins) * np.log(bins)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm:\\nThe new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the square root of the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the square root of the item size divided by the bin's current capacity, and applies a power function to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(np.log(bins - item) * np.sqrt(bins - item)))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (np.sqrt(item) / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the logarithm of the number of times the bin has been used, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size divided by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (item * np.log(np.arange(len(bins)) + 1)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) / 2\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the product of the bins and the item.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the reciprocal of the item size times the logarithm of the bin's capacity, and the cube of the item size divided by the difference between the bin's capacity and the item size, while also applying a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((1 / item) * np.log(bins)) + ((item ** 3) / (bins - item))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and the ratio of the remaining capacity to the item size, while also considering a certain function that incorporates the size of the current item and promotes performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + bins / item\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size minus the sum of the first and last digits of the item size, the reciprocal of the item size, an additional term incorporating the reciprocal of the square root of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size plus the square root of the item size.\\n\\nPython code for the new algorithm:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) * np.sqrt(bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item - int(str(item)[0]) - int(str(item)[-1])) + (1 / item) + ((1 / np.sqrt(item)) / item) + (0.5 * (bins / item + np.sqrt(item)))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a smaller remaining capacity ratio.\\n\\nNew code implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = 1 - bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it introduces a term incorporating the reciprocal of the item size, the product of the bin's remaining capacity ratio and the square root of the difference between the bin's capacity and the item size, and the exponential of the item size. \\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity_ratio = bins / np.max(bins)\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (1 / item) * (remaining_capacity_ratio * np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the cosine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * cos(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.square(bins) * np.log(bins)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.1, the square of the number of times the bin has been used, the sine of the item size, and cosine of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.1) + (np.arange(len(bins)) ** 2) + np.sin(item) + (np.cos(item) / 0.5)\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm:\\nThe new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the square root of the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the square root of the item size divided by the bin's current capacity, and applies a power function to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(np.log(bins - item) * np.sqrt(bins - item)))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (np.sqrt(item) / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the logarithm of the number of times the bin has been used, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size divided by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (item * np.log(np.arange(len(bins)) + 1)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) / 2\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the product of the bins and the item.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the cosine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * cos(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.1, the square of the number of times the bin has been used, the sine of the item size, and cosine of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.1) + (np.arange(len(bins)) ** 2) + np.sin(item) + (np.cos(item) / 0.5)\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.3, the square of the number of times the bin has been used, the tangent of the item size, and the square root of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(bins - item)) * np.log(item) + (np.exp(item) * 0.3) + (np.arange(len(bins)) ** 2) + np.tan(item) + (np.sqrt(item) / 0.5)\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the scores for each bin will be calculated based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, then multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, along with the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 2.0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(bins - item))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 2.0\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the logarithm of the number of times the bin has been used, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size divided by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (item * np.log(np.arange(len(bins)) + 1)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) / 2\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for the bins based on the ratio of their remaining capacity to the size of the current item, their relative positions, and a penalty factor for larger bins, with higher scores given to bins with smaller ratios, higher positions, and smaller penalty factors.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n # Calculate ratio of remaining capacity to item size\\n ratio = remaining_capacity / item\\n\\n # Calculate penalty factors for larger bins\\n penalty_factor = np.exp(-bins)\\n\\n # Assign scores based on ratio, bin position, and penalty factor\\n scores = ratio + np.arange(len(bins)) + penalty_factor\\n\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin. The scores are calculated by dividing the rest capacity of each bin by the item size, and then multiplying it with a decreasing factor.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios by an increasing factor\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin. The scores are calculated by dividing the rest capacity of each bin by the item size, and then multiplying it with a decreasing factor. In addition, the algorithm considers the number of already used bins in the score calculation to promote minimizing the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity of each bin to the item size\\n ratios = bins / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios by an increasing factor\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Adjust scores by considering the number of already used bins\\n scores *= np.exp(-0.1 * np.arange(0, len(bins)))\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"First, we calculate the remaining capacities of each bin after assigning the current item by subtracting the item size from the bin capacities. Then, we create a mask to identify the bins that still have remaining capacity and set their scores to an initial value of 1. Next, we divide the scores by the remaining capacities of the respective bins to adjust the scores based on the amount of remaining capacity. Finally, we return the scores as a numpy array.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins\\n mask = remaining_capacities > item\\n scores = np.zeros_like(bins, dtype=np.float64)\\n scores[mask] = 1 / remaining_capacities[mask]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm assigns items to bins based on a score function that takes into account both the difference between the current item and the rest capacities of bins and the number of times each bin has been used. The score for each bin is calculated by multiplying the square root of the absolute difference between the current item and the rest capacity of the bin by a factor of 0.5 and then adding the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = np.sqrt(np.abs(remaining_capacities)) * 0.5 + used_counts\\n return scores\",\n \"objective\": 0.05473,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that takes into account the ratio between the remaining capacity of each bin and the item size, the logarithm base 2 of the bin capacity, and the number of times each bin has been used, with higher scores given to bins with smaller ratios, larger logarithmic capacity, and smaller usage count.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = remaining_capacities / item + np.log2(bins * 2) + used_counts * (-0.2)\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that takes into account the difference between the current item and the rest capacities of bins and the number of times each bin has been used. The score for each bin is calculated by raising the difference between the current item and the rest capacity of the bin to the power of 2.5, multiplying it by a factor of 0.3, and then adding the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (remaining_capacities - item) ** 2.5 * 0.3 + used_counts\\n return scores\",\n \"objective\": 0.0651,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the score function, where the score for each bin is calculated by taking the logarithm base 2 of the sum of the square root of the difference between the rest capacity of the bin and the item size and the product of the bin capacity and a factor of 0.5, then subtracting the number of times the bin has been used multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = np.log2(np.sqrt(bins - item) + (bins * 0.5)) - used_counts * 0.1\\n return scores\",\n \"objective\": 0.08019,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the algorithms calculate scores for each bin based on some criteria such as remaining capacity, difference in capacity, or number of times the bin has been used.\\n\\nNew algorithm description: \\n\\nThe new algorithm assigns items to bins based on a score function that takes into account the difference between the current item and the rest capacities of bins, the number of times each bin has been used, and the inverse of the bin capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n inverse_capacities = 1 / bins\\n scores = np.sqrt(np.abs(remaining_capacities)) + used_counts * 0.5 + inverse_capacities\\n return scores\",\n \"objective\": 0.08049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the algorithms calculate scores for each bin based on some criteria such as remaining capacity, difference in capacity, or number of times the bin has been used.\\n\\nNew algorithm description: \\n\\nThe new algorithm assigns items to bins based on a score function that takes into account the difference between the current item and the rest capacities of bins, and the number of times each bin has been used. The score for each bin is calculated by adding the square root of the difference between the current item and the rest capacity of the bin, and the number of times the bin has been used, multiplied by a factor of 0.5.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = np.sqrt(np.abs(remaining_capacities)) + used_counts * 0.5\\n return scores\",\n \"objective\": 0.0822,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores the bins based on a combination of their remaining capacity and their positions in the list, with higher scores given to bins with larger capacities and lower positions in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n # Assign scores based on remaining capacity and bin position\\n scores = remaining_capacity + (len(bins)-1) - np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.10102,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the score function, where the score for each bin is calculated by multiplying the square root of the difference between the rest capacity of the bin and the item size by a factor of 0.5, and then subtracting the number of times the bin has been used multiplied by 0.1, and finally multiplying it with the item size divided by the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = np.sqrt(bins - item) * 0.5 - used_counts * 0.1\\n scores *= item / np.max(bins)\\n return scores\",\n \"objective\": 0.10655,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number 2 raised to the power of the bin's index from the score, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n bin_indices = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (capacities - item)) * 0.3 - (np.sqrt(2) ** bin_indices * 0.2) + (item * np.log(capacities) ** 0.4)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the sum of the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the product of the bin's capacity and the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities + item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities * (capacities - item))**0.3)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.6) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, raised to the power of 0.4, and finally subtracting the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((1 / capacities) / (bins - item)**0.7) - (np.sqrt(used_counts)**2 * 0.2) + (item * np.log(capacities + item)**0.4) - (np.log((bins - item)**(1/3)) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that calculates the average of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / (bins - item))**0.5) - (np.sqrt(used_counts)**2 * 0.5) + (item * np.log(np.maximum(bins - item, 1))**0.3)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / remaining_capacities) - (used_counts * 0.2) + (item * np.log(bins + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the sum of the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the product of the bin's capacity and the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities + item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities * (capacities - item))**0.3)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.6) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified score function that takes into account the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.8) + (item * np.sqrt(capacities)**0.5)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (np.sqrt(capacities - item))**0.8) - (used_counts * 0.6) + (item * np.sqrt(capacities)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - used_counts + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / remaining_capacities) - (used_counts * 0.2) + (item * np.log(bins + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the sum of the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the product of the bin's capacity and the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities + item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities * (capacities - item))**0.3)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified score function that takes into account the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.8) + (item * np.sqrt(capacities)**0.5)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - used_counts + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item)**0.8) / (np.sqrt(bins - item)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-8\\n scores = (np.log(bins.astype(float) + epsilon) / ((bins - item) + epsilon)**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item)**0.8) / (np.sqrt(bins - item)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (capacities - item) * 0.5 - used_counts**2 * 0.3 + item * np.sqrt(capacities) * 0.4\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, subtracting the square root of the number of times the bin has been used from the score squared, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.9, instead of 0.8. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) - np.sqrt(used_counts) ** 2 + item * np.log(bins + item) * 0.9\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-8\\n scores = (np.log(bins.astype(float) + epsilon) / ((bins - item) + epsilon)**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: \\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.6.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.7 - np.sqrt(np.arange(len(bins))) ** 2 * 0.3 + item * np.log(bins + item) * 0.6\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item)**0.8) / (np.sqrt(bins - item)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (capacities - item) * 0.5 - used_counts**2 * 0.3 + item * np.sqrt(capacities) * 0.4\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, subtracting the square root of the number of times the bin has been used from the score squared, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.9, instead of 0.8. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) - np.sqrt(used_counts) ** 2 + item * np.log(bins + item) * 0.9\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-8\\n scores = (np.log(bins.astype(float) + epsilon) / ((bins - item) + epsilon)**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log1p(capacities) / (bins - item) * 0.7) - (used_counts * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, subtracting the square root of the number of times the bin has been used from the score squared, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.9, instead of 0.8. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) - np.sqrt(used_counts) ** 2 + item * np.log(bins + item) * 0.9\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n scores = (np.log1p(capacities) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity and its relationship with the item size, as well as the number of times the bin has been used.\\n\\nNew Algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the bin's capacity, raised to the power of 0.2, and finally multiplying the score by the item size.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.sqrt(capacities) / (bins - item) * 0.7) - (np.arange(len(bins)) ** 2 * 0.3) + (item * np.log(capacities) ** 0.2) * item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n scores = (np.log1p(capacities) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.6, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item)**0.8)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.5 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (np.log1p(bins) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that calculates the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size, raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.4, and adds the product of the item size and the natural logarithm of the bin's capacity raised to the power of 0.8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / ((bins - item) ** 0.6) - np.arange(len(bins)) * 0.4 + (item * np.log(bins)) ** 0.8\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the bin's capacity divided by the difference between the bin's capacity and the item size, subtracts the square of the number of times the bin has been used from the score, then adds the product of the item size and the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) - np.arange(len(bins))**2 + (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on the bin's capacity and the item size, adding the item size divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.6, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item)**0.8)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.5 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins.astype(float) - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(bins.astype(float)) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, my new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.5) - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(bins - item) * 0.1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the highest preference score based on their rest capacity and the item size, and updates the rest capacity of the bin accordingly, until all items are assigned. The preference score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's rest capacity, a weight factor, and the number of times the bin has been used. The algorithm then updates the rest capacity of the chosen bin and repeats this process until all items are assigned, with the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_factor = 1.5\\n scores = (bins * weight_factor) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size plus 1, plus the number of times the bin has been used.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * (np.log(item + 1)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and adding the inverse of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (np.sqrt(remaining_capacities)) * 0.8 + (1 / (used_counts + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity and the number of items currently in each bin, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (bins[bins != bins.max()] - bins[bins != bins.max()] / np.count_nonzero(bins != bins.max()))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square of the item size divided by the difference between the bin's capacity and the item size.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.6) - (used_counts ** 2 * 0.3) + ((item ** 2) / (bins - item))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, plus the cube of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)**2 + np.arange(len(bins))**3)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that takes into account the difference between the logarithm of the current item and the logarithm of the rest capacities of bins, and the number of times each bin has been used. The score for each bin is calculated by subtracting the logarithm of the rest capacity from the logarithm of the bin's capacity, and then multiplying it by a factor of 0.5. Then the number of times the bin has been used is added to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n log_item = np.log(item)\\n log_rest_capacities = np.log(bins - item)\\n used_counts = np.arange(len(bins))\\n scores = (log_item - log_rest_capacities) * 0.5 + used_counts\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores for each bin based on their rest capacity and the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity and the item size divided by the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used.\\n\\nCode:\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item) + np.arange(len(bins)) ** 2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the given algorithms, the common backbone idea is to assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nThe new algorithm assigns items to bins based on a score function that takes into account the bin's current capacity, the item's size, and the number of times the bin has been used, aiming to minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n factor = 1.5 # Fixed value for the weight factor\\n scores = (bins * factor) / (bins - item + np.arange(len(bins))) # The score function is a combination of the bin's capacity, item size, and number of times used\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (np.log1p(bins) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that calculates the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size, raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.4, and adds the product of the item size and the natural logarithm of the bin's capacity raised to the power of 0.8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / ((bins - item) ** 0.6) - np.arange(len(bins)) * 0.4 + (item * np.log(bins)) ** 0.8\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the bin's capacity divided by the difference between the bin's capacity and the item size, subtracts the square of the number of times the bin has been used from the score, then adds the product of the item size and the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) - np.arange(len(bins))**2 + (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on the bin's capacity and the item size, adding the item size divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.6, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item)**0.8)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.5 - np.arange(len(bins)) * 0.8 + np.cbrt(bins)**2.5\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins.astype(float) - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(bins.astype(float)) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's remaining capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.2, and adding the number of times the bin has been used subtracted by 2 to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (remaining_capacities / np.sqrt(bins - item)) * 1.2 + (used_counts - 2)\\n return scores\",\n \"objective\": 0.02505,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the square of the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the cube root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities ** 2 / ((bins - item) ** 2) * 0.5) - ((np.cbrt(used_counts) ** 3) * 0.5) + (item * (np.cbrt(bins - item)) * 0.5)\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculate scores for each bin based on their rest capacity and the item size.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the square root of the bin's rest capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's rest capacity plus 1, and adding the reciprocal of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(bins - item)) * np.log(bins + 1) + (1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description:\\nThe new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracted by the logarithm of the number of times the bin has been used, squared.\\n\\nPython Implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / remaining_capacities) * 0.8 - np.log(used_counts + 1)**2\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the highest preference score based on their rest capacity and the item size, and updates the rest capacity of the bin accordingly, until all items are assigned. The preference score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's rest capacity, a weight factor, and the number of times the bin has been used. The algorithm then updates the rest capacity of the chosen bin and repeats this process until all items are assigned, with the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_factor = 1.5\\n scores = (bins * weight_factor) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size plus 1, plus the number of times the bin has been used.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * (np.log1p(item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and adding the inverse of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (np.sqrt(remaining_capacities)) * 0.8 + (1 / (used_counts + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculate scores for each bin based on their rest capacity and the item size.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the cube of the difference between the bin's capacity and the item size, multiplied by a factor of 1.5, and adding the reciprocal of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / ((remaining_capacities)**3) * 1.5 + (1 / (used_counts + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.9, and subtracting the square root of the number of times the bin has been used from the score.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (remaining_capacities) * 0.9 - np.sqrt(used_counts)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and adding the square root of the number of times the bin has been used to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (remaining_capacities) * 0.7 + np.sqrt(used_counts)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm assigns items to bins based on a modified score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the square root of the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.3) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.2) - (np.sqrt(item * (np.cbrt(bins - item))) * 0.1)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(capacities * item)) * 0.1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the score for each bin by multiplying the bin's current capacity divided by the difference between the bin's capacity and the item size, by a factor of 1.2, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and finally multiplying the score by a random factor between 0.9 and 1.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n random_factors = np.random.uniform(0.9, 1.1, len(bins))\\n scores = (capacities / (bins - item)) * 1.2 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3) * random_factors\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(bins - item)) * 0.4)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the item size multiplied by the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.cbrt(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 1.5) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: The new algorithm assigns items to bins based on a score function that considers the exponential of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 2, subtracting the exponent of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the exponential of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.exp(capacities) / np.sqrt(bins - item) ** 2 * 2) - (np.exp(used_counts) ** 2 * 0.5) + (item * np.exp(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.1, then adding the product of the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.8) - (np.sqrt(used_counts) ** 2 * 0.1) + (item * np.log(np.sqrt(bins - item)) * 0.4)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the bin's remaining capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the natural logarithm of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the fourth root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and finally subtracting the square root of the product of the item size and the fourth root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(remaining_capacities) / (bins - item) * 0.5) - (np.log(used_counts) ** 2 * 0.4) + (item * (bins - item) ** (1/4) * 0.3) - (np.sqrt(item * (bins - item) ** (1/4)) * 0.2)\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the score for each bin by multiplying the bin's current capacity divided by the difference between the bin's capacity and the item size, by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.1, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.1) + (item * (np.cbrt(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: Assign items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, adding the item size multiplied by the log of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2, and finally adding the square root of the log base 10 of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item)) * 0.3 - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.2) + (np.sqrt(np.log10(capacities + item)) * 0.1)\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\\n\\n# New algorithm - Changing the parameter settings of the score function\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.3) - (np.sqrt(used_counts) ** 3 * 0.7) + (item * (np.log(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.02234,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 3.0, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 3.0) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins - item) * 0.7)\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's remaining capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.2, and adding the number of times the bin has been used subtracted by 2 to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (remaining_capacities / np.sqrt(bins - item)) * 1.2 + (used_counts - 2)\\n return scores\",\n \"objective\": 0.02505,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the square of the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the cube root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities ** 2 / ((bins - item) ** 2) * 0.5) - ((np.cbrt(used_counts) ** 3) * 0.5) + (item * (np.cbrt(bins - item)) * 0.5)\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm:\\nThe new algorithm assigns an item to the bin with the highest preference score based on a modified formula that incorporates the rest capacity of the bin, the item size, and a weight factor, and updates the rest capacity of the bin accordingly, until all items are assigned.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * np.log(bins) + np.arange(len(bins)) + 0.5 * bins\\n return scores\",\n \"objective\": 0.02616,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.5) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.8) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log((bins - item) ** (1/3)) * 0.5)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm assigns items to bins based on a score function that considers the logarithm of the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size squared, multiplied by a factor of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(np.sqrt(capacities)) / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * np.log((capacities + item) ** 2) * 0.6)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / remaining_capacities) - used_counts + (item * (np.cbrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity, multiplied by a factor of 0.5, and finally, subtracting the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.8) - ((np.sqrt(used_counts) ** 2) * 0.2) + (item * np.log(capacities) * 0.5) - (item * np.log(capacities * item) * 0.1)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(capacities * item)) * 0.1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the score for each bin by multiplying the bin's current capacity divided by the difference between the bin's capacity and the item size, by a factor of 1.2, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and finally multiplying the score by a random factor between 0.9 and 1.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n random_factors = np.random.uniform(0.9, 1.1, len(bins))\\n scores = (capacities / (bins - item)) * 1.2 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3) * random_factors\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(bins - item)) * 0.4)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the item size multiplied by the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.cbrt(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 1.5) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: The new algorithm assigns items to bins based on a score function that considers the exponential of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 2, subtracting the exponent of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the exponential of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.exp(capacities) / np.sqrt(bins - item) ** 2 * 2) - (np.exp(used_counts) ** 2 * 0.5) + (item * np.exp(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's current capacity divided by the item size, subtracted by the square root of the difference between the bin's capacity and the item size, multiplied by the number of times the bin has been used, and added to the product of the item size and the hyperbolic tangent of the bin's current capacity divided by the item size, multiplied by the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item)) * np.log(capacities / item) - np.sqrt(bins - item) * used_counts + (item * np.tanh(capacities / item) * np.log(bins - item))\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - used_counts + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3. It also takes into account the square root of the item size multiplied by the logarithm of the maximum capacity of the bins, divided by the log base 10 of the bin's capacity plus one, multiplied by a factor of 0.1.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3) + (np.sqrt(item) * np.log(np.max(capacities)) / (np.log10(capacities + 1))) * 0.1\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.5) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.8) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log((bins - item) ** (1/3)) * 0.5)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n \\n # new algorithm\\n scores = (capacities / (bins - item)) * 0.8 + (item / (bins - item)) * 0.1 - (used_counts ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3)\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / remaining_capacities) - used_counts + (item * np.log(bins - item))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm assigns items to bins based on a score function that considers the logarithm of the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size squared, multiplied by a factor of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(np.sqrt(capacities)) / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * np.log((capacities + item) ** 2) * 0.6)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / remaining_capacities) - used_counts + (item * (np.cbrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity, multiplied by a factor of 0.5, and finally, subtracting the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.8) - ((np.sqrt(used_counts) ** 2) * 0.2) + (item * np.log(capacities) * 0.5) - (item * np.log(capacities * item) * 0.1)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(capacities * item)) * 0.1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.6 - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3. It also takes into account the square root of the item size multiplied by the logarithm of the maximum capacity of the bins, divided by the log base 10 of the bin's capacity plus one, multiplied by a factor of 0.1.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3) + (np.sqrt(item) * np.log(np.max(capacities)) / (np.log10(capacities + 1))) * 0.1\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the product of the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2) - (np.log(capacities + item) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.15 instead of 0.2, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.6) - (used_counts * 0.15) + (item * np.sqrt(capacities) ** 0.25)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a revised scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.2 instead of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.5) - (used_counts * 0.2) + (item * np.sqrt(capacities) ** 0.3)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n \\n # new algorithm\\n scores = (capacities / (bins - item)) * 0.8 + (item / (bins - item)) * 0.1 - (used_counts ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3)\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / remaining_capacities) - used_counts + (item * np.log(bins - item))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm assigns items to bins based on a score function that considers the logarithm of the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size squared, multiplied by a factor of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(np.sqrt(capacities)) / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * np.log((capacities + item) ** 2) * 0.6)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item)) * 0.6 - (np.sqrt(np.arange(len(bins))) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number 2 raised to the power of the bin's index from the score, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n bin_indices = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (capacities - item)) * 0.3 - (np.sqrt(2) ** bin_indices * 0.2) + (item * np.log(capacities) ** 0.4)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3. It also takes into account the square root of the item size multiplied by the logarithm of the maximum capacity of the bins, divided by the log base 10 of the bin's capacity plus one, multiplied by a factor of 0.1.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins + item) * 0.3) + (np.sqrt(item) * np.log(np.max(bins)) / (np.log10(bins + 1))) * 0.1\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.6 - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the logarithm of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and twice the item size, raised to the power of 0.4.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / ((capacities - item) ** 0.5)) - (np.log(used_counts + 1) ** 2 * 0.2) + (item * np.log(capacities + 2 * item) ** 0.4)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the product of the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2) - (np.log(capacities + item) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.15 instead of 0.2, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.6) - (used_counts * 0.15) + (item * np.sqrt(capacities) ** 0.25)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / (capacities - item)) - (used_counts * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a revised scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.2 instead of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.5) - (used_counts * 0.2) + (item * np.sqrt(capacities) ** 0.3)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item)) * 0.6 - (np.sqrt(np.arange(len(bins))) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number 2 raised to the power of the bin's index from the score, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n bin_indices = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (capacities - item)) * 0.3 - (np.sqrt(2) ** bin_indices * 0.2) + (item * np.log(capacities) ** 0.4)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (0.6 / (capacities - item + 1e-6)) - (used_counts * 0.4) + (item * np.log(capacities + item + 1e-6) * 0.5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the logarithm of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and twice the item size, raised to the power of 0.4.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / ((capacities - item) ** 0.5)) - (np.log(used_counts + 1) ** 2 * 0.2) + (item * np.log(capacities + 2 * item) ** 0.4)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the product of the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2) - (np.log(capacities + item) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that calculates the average of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / (bins - item))**0.5) - (np.sqrt(used_counts)**2 * 0.5) + (item * np.log(np.maximum(bins - item, 1))**0.3)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / remaining_capacities) - (used_counts * 0.2) + (item * np.log(bins + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a revised scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.2 instead of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.5) - (used_counts * 0.2) + (item * np.sqrt(capacities) ** 0.3)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nMy idea is to create a score function that takes into account the current rest capacities of the bins and the size of the item to be assigned. The main steps involve calculating the score for each bin based on its rest capacity, with a penalty for bins that are at maximum capacity, and then returning the scores for assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.03984,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe main idea is to assign a score to each bin based on its remaining capacity and the size of the current item. The score will be calculated using a novel formula that takes into account both the remaining capacity and the difference between the bin capacity and the item size. The main steps include calculating the score for each bin using the novel formula, and returning the scores for each bin for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1\\n return scores\",\n \"objective\": 1.51534,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe score function will calculate the scores for each bin based on the rest capacity and the size of the item to be assigned. The main steps include calculating the difference between the rest capacity of each bin and the item size, penalizing bins with maximum capacity, and updating the scores with additional criteria to favor more efficient bin usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = bins[i] - item\\n \\n max_capacity = max(bins)\\n max_count = list(bins).count(max_capacity)\\n if max_count == 1:\\n max_index = np.argmax(bins)\\n scores[max_index] -= item\\n \\n return scores\",\n \"objective\": 1.51484,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates the score for each bin based on a combination of the rest capacity and a penalty for using a bin. The main steps involve calculating the score for each bin by taking into account the rest capacity and penalizing the bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = 1 - (bins/max_capacity) # Penalize bins with maximum capacity\\n scores = (bins - item) * penalty # Calculate scores based on rest capacity and penalty\\n return scores\",\n \"objective\": 0.13211,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI propose a novel score function that calculates the scores for the bins based on a combination of their rest capacity and a penalty factor for fully utilized bins. The main steps involve calculating the base score for each bin as the difference between rest capacity and item size, and then applying a penalty factor if the rest capacity equals the maximum capacity. The final scores will be the combination of the base scores and the penalty scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n base_scores = bins - item\\n penalty_scores = np.where(bins == max(bins), -item, 0)\\n scores = base_scores + penalty_scores\\n return scores\",\n \"objective\": 0.32559,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates the scores for each bin based on the remaining capacity and the difference between the bin capacity and the item size. The scores will be higher for bins with more remaining capacity and smaller difference between the capacity and the item size. Then, I will implement this in Python as a function named score that accepts 'item' and 'bins' as inputs and returns 'scores' as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] - item + (max_capacity - bins[i])\\n return scores\",\n \"objective\": 0.04226,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nIdea: \\nThe novel score function will calculate the scores for each bin based on their remaining capacity and the size of the current item. It will penalize bins that are close to reaching their maximum capacity in order to minimize the number of used bins.\\n\\nPython function:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins) \\n scores = (max_capacity - bins) / max_capacity - (max_capacity - bins - item) / max_capacity\\n return scores\",\n \"objective\": 0.06812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates the scores for each bin based on their rest capacity, with consideration of the maximum capacity constraint. The main steps include identifying the bins with enough capacity, computing their scores based on the rest capacity, and penalizing the bins at maximum capacity by assigning them lower scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + (bins == bins.max()))\\n return scores\",\n \"objective\": 0.84787,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function based on the remaining capacity of each bin, considering both the absolute capacity and the proximity to the item size. The main steps include calculating the absolute remaining capacity, normalizing it, and then adjusting the scores based on the proximity to the item size. This function aims to provide a more balanced and efficient assignment of items to bins, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = max_capacity - bins\\n normalized_capacity = remaining_capacity / max_capacity\\n proximity_adjustment = np.abs(bins - item) / item\\n scores = normalized_capacity * (1 - proximity_adjustment)\\n return scores\",\n \"objective\": 0.03803,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nIdea: The score function will calculate the scores for each bin based on the rest capacity and the efficiency of space utilization, resulting in a more complex and efficient scoring system.\\n\\nPython function:\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04095,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI propose a score function that ranks the feasible bins based on a combination of their rest capacity and the difference between their rest capacity and the current item size. The main steps include calculating the difference between the rest capacity and the item size for each bin, and then applying a weighted sum to obtain the final scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n differences = bins - item\\n scores = (bins / (differences + 1)) * (differences > 0)\\n return scores\",\n \"objective\": 0.05071,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates scores for each bin based on their remaining capacity and the size of the current item. First, I will calculate the available capacity for each bin by subtracting the item size from the rest capacities. Then, I will design a scoring mechanism that penalizes bins with higher remaining capacity, encouraging the use of bins with closer capacity to the item size. Finally, I will implement this scoring function in Python using NumPy for efficient array operations and return the scores for each bin for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n penalty = 1 / (1 + np.exp(available_capacity)) # Penalize bins with higher remaining capacity\\n scores = 1 - penalty # Invert penalties to get scores\\n return scores\",\n \"objective\": 0.79404,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to calculate the score function for each bin by considering the ratio of remaining capacity to the item size, and then penalize the bins which are close to full capacity in order to minimize the number of used bins. In Python, I will implement this as a function named score, which will take 'item' and 'bins' as inputs and return 'scores' as the output. I will ensure self-consistency by validating the inputs and outputs and implementing the scoring logic with Numpy arrays for efficient computation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.9, utilization_ratio, 1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.04045,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to create a scoring function that takes into account the rest capacities of the bins and assign a higher score to the bins with larger capacities. The main steps include calculating the ratio of item size to bin capacity, taking the logarithm of the ratios to ensure a balanced scoring, and finally assigning the scores to the bins to prioritize usage of the bins with larger capacities. \\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n scores = 1 / log_ratios\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n scores = 1 / log_ratios\\n return scores\",\n \"objective\": 0.89597,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI will design a score function that calculates the scores for each bin based on their rest capacity and the size of the current item. The score will be higher for bins with more capacity remaining, and the function will also consider minimizing the number of used bins. In each step, the item will be assigned to the bin with the maximum score.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI will compute the score for each bin by taking the ratio of item size to the rest capacity of the bin, and then I will apply a penalty to the scores of bins with maximum capacity to avoid using them unnecessarily. Then, I will return the computed scores as the output. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n max_capacity = np.max(bins)\\n penalty = (max_capacity - bins) / max_capacity\\n scores -= penalty\\n return scores\",\n \"objective\": 0.94074,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will calculate the scores for each bin based on their current rest capacity and the size of the item to be assigned. The main steps include determining the feasible bins, calculating the scores based on a complex formula involving the rest capacity and item size, and returning the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Determine the feasible bins\\n feasible_bins = bins[bins >= item]\\n \\n # Calculate scores based on a complex formula\\n scores = (feasible_bins - item) / (feasible_bins * np.log(feasible_bins))\\n \\n return scores\",\n \"objective\": 1.38193,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy novel score function first calculates the available capacity in each bin after the item is assigned, then computes a weighted score for each bin based on the remaining capacity, priority of the bin, and other factors. Finally, it returns the scores for each bin to determine the optimal assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate available capacities in each bin\\n avail_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Compute weighted scores based on remaining capacity and other factors\\n scores = (1 - (avail_capacity / max_capacity)) * (1 / (1 + np.exp(-0.5 * avail_capacity))) * np.random.rand(len(bins))\\n return scores\",\n \"objective\": 0.08401,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy novel score function will calculate the scores for each bin based on their remaining capacities and the size of the current item. First, it will filter out the bins with exactly the same capacity as the item, and then calculate the scores for the rest of the bins by considering both the ratio of remaining capacity to item size and the overall utilization of the bin. The higher the score, the more suitable the bin will be for assigning the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n valid_bins = bins[bins != item] # Remove bins with exactly the same capacity as the item\\n scores = (valid_bins - item) / item # Calculate scores based on remaining capacity and item size\\n scores -= np.log(1 + 1/valid_bins) # Consider overall utilization of the bin\\n return scores\",\n \"objective\": 0.08693,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe score function will calculate the scores for each bin based on their rest capacities and the size of the current item. The main steps include calculating the ratio of rest capacity to item size for each bin, penalizing bins with maximum capacity, and normalizing the scores to ensure self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / item\\n scores[bins == np.max(bins)] -= 1\\n scores = np.maximum(scores, 0) / np.sum(np.maximum(scores, 0))\\n return scores\",\n \"objective\": 0.32659,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins, using a different penalty calculation method and a modified form of the score calculation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins), 0, -1)\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function based on the remaining capacity of each bin, considering both the absolute capacity and the proximity to the item size. The main steps include calculating the absolute remaining capacity, normalizing it, and then adjusting the scores based on the proximity to the item size. This function aims to provide a more balanced and efficient assignment of items to bins, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = max_capacity - bins\\n normalized_capacity = remaining_capacity / max_capacity\\n proximity_adjustment = np.abs(bins - item) / item\\n scores = normalized_capacity * (1 - proximity_adjustment)\\n return scores\",\n \"objective\": 0.03803,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins, using a penalty calculation method involving the square of the index and a modified form of the score calculation.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(1, len(bins) + 1)\\n scores = bins / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = bins / (bins - item)**2 - np.arange(len(bins))**2\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item)**2 - np.arange(len(bins))**2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a linear priority of the bin, where the priority is set to the index of the bin.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and the priority of the bin based on its index, resulting in a more linear and index-based scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / np.arange(1, len(bins) + 1)\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for bins with a capacity below a certain threshold, encouraging the utilization of higher capacity bins, using a novel penalty calculation method and a modified form of the score calculation.\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins))) # New penalty calculation method\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n penalty[bins < threshold] *= 2 # Apply penalty for bins below the threshold\\n scores = bins / (bins - item + 0.1) - penalty # Modified score calculation\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins)))\\n threshold = 0.2 * bins.max()\\n penalty[bins < threshold] *= 2\\n scores = bins / (bins - item + 0.1) - penalty\\n scores -= np.where(bins == bins.max(), np.inf, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and the priority of the bin. The priority of each bin will be set to 1/2 raised to the power of its index, resulting in a exponential and index-based scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / 2 ** np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for bins that are closer to full capacity, promoting the utilization of lower index bins and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.log(np.arange(2, len(bins) + 2)) # Apply penalty based on the logarithm of the bin index\\n utilization_ratio = 1 - (bins - item) / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.95, utilization_ratio, 1) # Penalize bins close to full capacity\\n scores = penalized_utilization_ratio * penalty # Calculate scores based on penalized utilization ratio and penalty\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm will calculate the score function for each bin by considering the ratio of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity in order to minimize the number of used bins. It will be implemented in Python as a function named score, which will take 'item' and 'bins' as inputs and return 'scores' as the output. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = item / remaining_capacity\\n penalized_utilization_ratio = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm will assign scores to each bin based on the inverse of the remaining capacities, penalizing bins with higher remaining capacities and ensuring self-consistency without a random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (1 + bins)\\n return scores\",\n \"objective\": 0.03984,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the scores for each bin based on the reciprocal of the difference between the remaining capacity of the bin and the item size, and then penalize the bins which are close to full capacity, ensuring self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to calculate the score function for each bin by considering the ratio of remaining capacity to the item size, and then penalize the bins which are close to full capacity in order to minimize the number of used bins. In Python, I will implement this as a function named score, which will take 'item' and 'bins' as inputs and return 'scores' as the output. I will ensure self-consistency by validating the inputs and outputs and implementing the scoring logic with Numpy arrays for efficient computation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.9, utilization_ratio, 1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.04045,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nIdea: The score function will calculate the scores for each bin based on the rest capacity and the efficiency of space utilization, resulting in a more complex and efficient scoring system.\\n\\nPython function:\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04095,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm will assign scores to each bin based on the rank of the remaining capacities, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ranks = np.argsort(bins)\\n penalized_ranks = np.where(bins >= 0.9 * np.max(bins), np.inf, ranks)\\n scores = 1 / (1 + penalized_ranks)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new score function will calculate the score for each bin based on the ratio of the remaining capacity of the bin to the size of the current item, with an added penalty for bins that are at maximum capacity and prioritize bins with lower index values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / item) - (bins == max_capacity) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated by taking the ratio of the remaining capacity of each bin to the item size, with a penalty applied for bins that are closer to full capacity, ensuring efficient assignment and minimal usage of bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity_ratio = bins / item\\n penalized_remaining_capacity_ratio = np.where(remaining_capacity_ratio < 0.95, remaining_capacity_ratio, 1)\\n scores = penalized_remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.04226,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new score function will calculate the score for each bin by considering the ratio of remaining capacity to the item size and penalizing bins with close to full capacity, using a different threshold value for penalization compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.8, utilization_ratio, 1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a weighted combination of the utilization ratio, a modified exponential decay factor, and a dynamic adjustment to assign scores to each bin and minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n decay_factor = np.exp(-(bins - item)**2)\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (item * 1.5) / (np.exp(bins - item) + 0.5) * decay_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the utilization ratio, a novel dynamic adjustment, and a non-linearly decaying factor, incorporating a different parameter setting to facilitate the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1.5)) + 0.4)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.7) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, item size, and utilization ratio to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n adjustment_factor = (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1)\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), adjustment_factor + 0.8, adjustment_factor + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a modified scoring function based on the remaining capacity of the bins, item size, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.5, (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a modified scoring function based on the remaining capacity of the bins, item size, and a linearly decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm uses a scoring function with parameters such as utilization ratio, dynamic adjustment, and a linearly decaying factor, calculated using different parameter settings, to assign scores to each bin based on their remaining capacity, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms aim to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins, using a scoring function based on utilization ratio, dynamic adjustment, and an exponentially decaying factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a weighted combination of the utilization ratio, a modified exponential decay factor, and a dynamic adjustment to assign scores to each bin and minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (item * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-(bins - item)**2) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.85, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the utilization ratio, a unique dynamic adjustment, and a non-linearly decaying factor with a customized weighting factor to facilitate the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a modified scoring function based on the remaining capacity of the bins, item size, and a linearly decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n static_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the utilization ratio, a unique dynamic adjustment, and a non-linearly decaying factor with a customized weighting factor to facilitate the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins) / (np.exp(bins - item) + 1) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on a modified utilization ratio, a dynamic adjustment factor, and a linearly increasing factor to facilitate item assignment. \\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins) / (np.exp(bins - item) + 1) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1))\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the item size, remaining capacity of the bins, utilization ratio, dynamic adjustment, and an exponentially decaying factor to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.9, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on a modified utilization ratio, a dynamic adjustment factor, and a linearly increasing factor to facilitate item assignment. \\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm incorporates a utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.6) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a non-linear combination of trigonometric functions and a custom dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), 1.2 * np.sin(bins * np.pi / item) + 0.7, 1.1 * np.cos(bins * np.pi / item) + 0.5)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1))\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on a modified utilization ratio, a dynamic adjustment factor, and a linearly increasing factor to facilitate item assignment. \\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm incorporates a utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.6) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a non-linear combination of trigonometric functions and a custom dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), 1.2 * np.sin(bins * np.pi / item) + 0.7, 1.1 * np.cos(bins * np.pi / item) + 0.5)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1))\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff) + 0.8, (1 - diff / bins) * np.sqrt(diff) + 0.3)\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 0.5) + 0.3)\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is based on a combination of item size, remaining bin capacity, a novel weighted dynamic adjustment, and a modified decaying factor to assign scores to each bin, with the aim to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n weight = np.sqrt((bins - item) + 1)\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * weight + 0.8, (1 - diff / bins) * weight + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm incorporates a combination of utilization ratio, a modified exponential decay factor, and a dynamic adjustment based on the ratio of item size to bin capacity to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), utilization_ratio * np.sqrt(bins - item + 2) + 0.9, utilization_ratio * np.sqrt(bins - item + 1) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins / 2) / (np.exp(diff / 2) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin using a combination of the utilization ratio, a dynamic adjustment, and a non-linear decay factor to optimize item distribution and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (item * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm incorporates a utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins. It uses a weighted combination of these factors to calculate the scores for bin assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, incorporating a penalty for the deviation from the average capacity of all bins, and also considering the absolute difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity)\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.2 * bins.max() # Penalty for close to full capacity\\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 1)\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will use the concept of geometric series priority, where the score function will be calculated based on the geometric series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 2 ** np.arange(len(bins)) # Geometric series priority\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = priority / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of the bin, incorporating a penalty for bins with remaining capacity close to full, and further adjusting the scores based on the index of the bins in a non-linear manner, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.log(bins) - (bins - item < threshold) * 2 - np.sqrt(bin_indexes) ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilizing a modified priority calculation and penalty method based on remaining bin capacity to ensure self-consistency and avoid randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(1, len(bins) + 1) ** 2 # Modified priority calculation\\n threshold = 0.3 * bins.max()\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = bins / (bins - item) * priority - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the scores for each bin based on the reciprocal of the difference between the remaining capacity of the bin and the item size, and then penalize the bins which are close to full capacity, ensuring self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 / (bins - item)\\n scores = np.maximum(utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function based on the remaining capacity of each bin, considering both the absolute capacity and the proximity to the item size. The main steps include calculating the absolute remaining capacity, normalizing it, and then adjusting the scores based on the proximity to the item size. This function aims to provide a more balanced and efficient assignment of items to bins, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = max_capacity - bins\\n normalized_capacity = remaining_capacity / max_capacity\\n proximity_adjustment = np.abs(bins - item) / item\\n scores = normalized_capacity * (1 - proximity_adjustment)\\n return scores\",\n \"objective\": 0.03803,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins, utilizing a different penalty calculation method and a modified form of the score calculation.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins), 0, -1) ** 2\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will use the concept of exponential priority, where the score function will be calculated based on the exponential of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = np.exp(priority) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a penalty based on the square of the index of the bin, ensuring a unique scoring system with emphasis on lower index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a weighted combination of the item size and the remaining capacity of the bin, incorporating a penalty for bins close to full capacity, ensuring self-consistency and promoting balanced utilization of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins) + 1) ** 2 # Weighted combination of index values\\n utilization_ratio = item / (bins - item) # Relationship between item size and remaining capacity\\n threshold = 0.3 * bins.max()\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = utilization_ratio * weights - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a penalty based on the square of the index of the bin, ensuring a unique scoring system with emphasis on lower index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins))\\n scores = bins / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a quadratic priority of the bin, where the priority is set to the square of the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will use the concept of harmonic priority, where the score function will be calculated based on the harmonic series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / (np.arange(len(bins)) + 1)\\n scores = 1 / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a linear priority of the bin, where the priority is set to the index of the bin.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and the priority of the bin based on its index, resulting in a more linear and index-based scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / np.arange(1, len(bins) + 1)\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for bins with a capacity below a certain threshold, encouraging the utilization of higher capacity bins, using a novel penalty calculation method and a modified form of the score calculation.\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins))) # New penalty calculation method\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n penalty[bins < threshold] *= 2 # Apply penalty for bins below the threshold\\n scores = bins / (bins - item + 0.1) - penalty # Modified score calculation\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins)))\\n threshold = 0.2 * bins.max()\\n penalty[bins < threshold] *= 2\\n scores = bins / (bins - item + 0.1) - penalty\\n scores -= np.where(bins == bins.max(), np.inf, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will be calculated based on the logarithm of the remaining capacity of the bin, with a penalty applied for bins with close to full capacity, while also considering a specific threshold for the item size and an additional constraint on the index of the bins, ensuring a unique and efficient scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.log(bins) - (bins - item < threshold) * 2 - bin_indexes ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff) + 0.5, (1 - diff / bins) * np.sqrt(diff))\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 0.5) + 0.3)\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is based on a combination of item size, remaining bin capacity, a novel weighted dynamic adjustment, and a modified decaying factor to assign scores to each bin, with the aim to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n weight = np.sqrt((bins - item) + 1)\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * weight + 0.8, (1 - diff / bins) * weight + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm incorporates a combination of utilization ratio, a modified exponential decay factor, and a dynamic adjustment based on the ratio of item size to bin capacity to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), utilization_ratio * np.sqrt(bins - item + 2) + 0.9, utilization_ratio * np.sqrt(bins - item + 1) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins / 2) / (np.exp(diff / 2) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin using a combination of the utilization ratio, a dynamic adjustment, and a non-linear decay factor to optimize item distribution and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (item * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will use a linear combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff + 4) + 0.6, (1 - diff / bins) * np.sqrt(diff + 0.7) + 0.2)\\n scores = (bins) / (np.exp(diff) + 0.8) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on a novel combination of the utilization ratio, adaptive dynamic adjustment, and a customized decaying factor, introducing a new element to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.6, (1 - diff / bins) * np.sqrt(diff + 1) + 0.4)\\n scores = (bins * 1.8) / (np.exp(diff) + 0.6) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and a unique scoring mechanism.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_threshold = 0.3 * bins.max()\\n penalty = (bins - item) < penalty_threshold\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with an additional penalty for bins close to full capacity, ensuring self-consistency and a unique scoring mechanism.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalty for bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component, and minimizing the number of used bins by prioritizing bins with higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins - item) < 0.2 * bins.max() # Penalty for bins close to full capacity\\n scores = 1 / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, incorporating a penalty for the bins with capacities close to full, and also considering a unique adjustment factor for each bin based on its position, resulting in a novel and efficient scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will be based on the concept of geometric priority, where the score function will be calculated by taking the geometric mean of the priority of the bin with the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and minimizing the number of used bins. \\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, incorporating a penalty for the deviation from the average capacity of all bins, and also considering the absolute difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity)\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 1)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will use the concept of geometric series priority, where the score function will be calculated based on the geometric series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_threshold = 0.2 * bins.max()\\n penalty = (bins - item) < penalty_threshold\\n scores = 2 ** np.arange(len(bins)) / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 1.7\\n scores = scores / np.log10(bin_indexes + 1)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the item size to the remaining capacity of the bin, while also implementing a non-linear adjustment for the scores and penalizing the bins with capacities close to full, ensuring self-consistency and minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.25 * bins.max() \\n scores = 1 / (bins - item) - (bins - item < penalty) * 2.5\\n scores = scores / np.log2(np.arange(len(bins)) + 2)\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will use the concept of exponential priority, where the score function will be calculated based on the exponential series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_threshold = 0.2 * bins.max()\\n penalty = (bins - item) < penalty_threshold\\n scores = np.exp(np.arange(len(bins))) / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the relative position of the bin in the array, with an additional penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.3 * max_bins\\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.log(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the square root of the remaining capacity of the bin, penalizing bins with remaining capacity close to full, and further adjusting the scores based on the index of the bins in a non-linear manner, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.sqrt(bins) - (bins - item < threshold) * 2 - np.sqrt(bin_indexes) ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the ratio between the item size and the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item / (bins - item))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.15 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 1.5\\n scores = scores / np.log10(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of the bin, incorporating a penalty for bins with remaining capacity close to full, and further adjusting the scores based on the index of the bins in a non-linear manner, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.log(bins) - (bins - item < threshold) * 2 - np.sqrt(bin_indexes) ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilizing a modified priority calculation and penalty method based on remaining bin capacity to ensure self-consistency and avoid randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(1, len(bins) + 1) ** 2 # Modified priority calculation\\n threshold = 0.3 * bins.max()\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = bins / (bins - item) * priority - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00730,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item**2 + 1) / (bins - item + 1) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * max(bins)\\n scores = np.log(item**2) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then adjust the scores non-linearly with an additional penalty for bins close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.2 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.25 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.sqrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, squared, with an additional non-linear adjustment for the scores, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item**2) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.2 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a mixture of the square root and the natural logarithm of the item size to the remaining capacity of the bin, with an additional penalty for bins close to full capacity, ensuring a unique and consistent scoring system without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n threshold_penalty = 0.2 * max_bins\\n penalty = (bins - item) < threshold_penalty\\n scores = (np.sqrt(item) + np.log(item)) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component, and minimizing the number of used bins by prioritizing bins with higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins - item) < 0.2 * bins.max() # Penalty for bins close to full capacity\\n scores = 1 / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description:\\nThe new algorithm will calculate the score function by taking the reciprocal of the priority of the bin with remaining capacity, with a penalty for bins close to full capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n reciprocal_priority = 1 / priority\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = reciprocal_priority / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, penalizing the bins with larger capacities, and also considering the absolute difference between the bin capacity and the item size, with a smaller penalty for the deviation from the average capacity of all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity) * 0.5 # Smaller penalty for deviation from average capacity\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position, resulting in an efficient and modified scoring system to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 5)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nNew algorithm: The score function will calculate the scores for each bin based on an exponential function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position of the bin, ensuring self-consistency and a different form from the given algorithms.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.2 * np.max(bins) \\n bin_indexes = np.arange(len(bins))\\n scores = np.exp(1 / (bins - item)) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == np.max(bins))[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin using a linear function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position, resulting in an efficient and modified scoring system to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = np.max(bins)\\n penalty = 0.2 * max_bins\\n bin_indexes = np.arange(len(bins))\\n adjusted_item = bins - item\\n \\n scores = (1 / adjusted_item) - (adjusted_item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 3)\\n \\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, incorporating a penalty for the bins with capacities close to full, and also considering a unique adjustment factor for each bin based on its position, resulting in a novel and efficient scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will be based on the concept of geometric priority, where the score function will be calculated by taking the geometric mean of the priority of the bin with the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and minimizing the number of used bins. \\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cube root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.cbrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item**2 + 1) / (bins - item + 1) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, with an adjustment for the utilization ratio and a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = (item**(1/3)) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * max(bins)\\n scores = np.log(item**2) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then adjust the scores non-linearly with an additional penalty for bins close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.2 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.25 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.sqrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.25 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - (penalty * 0.5)\\n return scores\",\n \"objective\": 0.02354,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, squared, with an additional non-linear adjustment for the scores, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item**2) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.2 * np.max(bins)\\n scores = np.log(item) / (bins - item) - (bins - item < penalty) * 1.0\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a mixture of the square root and the natural logarithm of the item size to the remaining capacity of the bin, with an additional penalty for bins close to full capacity, ensuring a unique and consistent scoring system without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n threshold_penalty = 0.2 * max_bins\\n penalty = (bins - item) < threshold_penalty\\n scores = (np.sqrt(item) + np.log(item)) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the exponential of the ratio between the item size and the remaining capacity of the bin, penalizing bins with remaining capacity below a certain threshold and ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.exp(item / bins) - penalty\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component, and minimizing the number of used bins by prioritizing bins with higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins - item) < 0.2 * bins.max() # Penalty for bins close to full capacity\\n scores = 1 / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description:\\nThe new algorithm will calculate the score function by taking the reciprocal of the priority of the bin with remaining capacity, with a penalty for bins close to full capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n reciprocal_priority = 1 / priority\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = reciprocal_priority / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, penalizing the bins with larger capacities, and also considering the absolute difference between the bin capacity and the item size, with a smaller penalty for the deviation from the average capacity of all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity) * 0.5 # Smaller penalty for deviation from average capacity\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position, resulting in an efficient and modified scoring system to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 5)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n adjust = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the exponential of the remaining capacity of the bins and logarithm of the item size to minimize the number of used bins. It uses a modified scoring function based on the exponential of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.1)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithmic of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n adjusted_bins = bins - item\\n scores = np.log(item) / adjusted_bins - (adjusted_bins < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm improves item distribution by adjusting the scoring function based on remaining capacity, utilization ratio, and item size, using different parameter settings for the dynamic adjustment and exponentially decaying factor to assign scores to each bin, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will assign scores to the bins based on the ratio of the logarithm of the item size to the remaining capacity of the bin, incorporating a dynamic adjustment for optimization and a factor that penalizes bins close to full capacity, ensuring consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n adjusted_bins = bins - item\\n utilization_ratio = np.log(item) / (adjusted_bins + 1)\\n dynamic_adjustment = np.where(adjusted_bins > (item * 2), utilization_ratio * 1.2, utilization_ratio * 0.8)\\n scores = utilization_ratio + dynamic_adjustment - (adjusted_bins < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cube root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.cbrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item**2 + 1) / (bins - item + 1) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n adjusted_bins = bins - item\\n scores = np.sqrt(item) / adjusted_bins - (adjusted_bins < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm dynamically adjusts the scoring function to minimize the number of used bins and optimize item distribution by considering the item size and remaining capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm dynamically adjusts the scoring function to minimize the number of used bins and optimize item distribution by considering the item size and remaining capacity of the bins, using a modified formula that takes into account both the remaining capacity and the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modified_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) + modified_adjustment\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the utilization ratio and a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, with an adjustment for the utilization ratio and a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = (item**(1/3)) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.25 * np.max(bins) # Penalty for bins close to full capacity\\n scores = np.log(item) / (bins - item) - (bins - item < penalty) * 1.2\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * max(bins)\\n scores = np.log(item**2) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm dynamically adjusts the scoring function based on the utilization ratio and a decaying factor to assign scores to each bin for item assignment, optimizing item distribution and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n decaying_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * decaying_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n adjust = np.where((bins - item) > (item * 2), (1 - (bins - item) / bins) * np.sqrt(bins - item + 2) + 0.8, (1 - (bins - item) / bins) * np.sqrt(bins - item + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and a modified decay factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the item size, remaining capacity of the bins, and a combination of dynamic adjustment and an exponentially decaying factor to assign scores to each bin to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.4)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes non-linear dynamic adjustment and the integration of item size and remaining capacity to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n non_linear_dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.2, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + non_linear_dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a combination of the square root of the utilization ratio, the natural logarithm of the item size, and an adjusted dynamic factor to calculate the scores for each bin assignment to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.3)\\n scores = (np.log(item) + bins * 1.5) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the utilization ratio, dynamic adjustment, and an exponentially decaying factor while also considering the logarithm of the item size and exponential of the remaining capacity of the bins, ultimately facilitating the selection of the bin with the maximum score for item assignment by using a modified scoring function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the utilization ratio, dynamic adjustment, and an exponentially decaying factor while also considering the logarithm of the item size and exponential of the remaining capacity of the bins, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.15) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm aims to optimize item distribution by leveraging the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the exponential of the remaining capacity of the bins and logarithm of the item size to minimize the number of used bins. It uses a modified scoring function based on the exponential of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.1)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\\n\\n# Simplified version\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = utilization_ratio * np.sqrt(bins - item + 1) + 0.6\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to minimize the number of used bins and optimize item distribution by adjusting the scoring function based on the item size and the remaining capacity of the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.4)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm aims to optimize item distribution by considering the utilization ratio, dynamic adjustment, and a modified scoring function that takes into account the remaining capacity of the bins and the item size. The scores are calculated by using an adjusted formula based on the remaining capacity and item size while incorporating the utilization ratio and a dynamic adjustment factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.1, (utilization_ratio * np.sqrt(bins - item)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a modified approach of the scoring function by incorporating the item size, remaining bin capacity, utilization ratio, and dynamic adjustment, ultimately aiming to minimize the number of used bins while optimizing item distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.25)\\n scores = (bins * 1.3) / (np.log(bins + 1) * (bins - item + 2)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm improves item distribution by adjusting the scoring function based on remaining capacity, utilization ratio, and item size, using different parameter settings for the dynamic adjustment and exponentially decaying factor to assign scores to each bin, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating item size, remaining capacity of the bins, and a modified scoring function based on the utilization ratio and dynamic adjustment to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n adjust = np.where((bins - item) > (item * 2), (1 - (bins - item) / bins) * np.sqrt(bins - item + 2) + 0.8, (1 - (bins - item) / bins) * np.sqrt(bins - item + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and a modified decay factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the item size, remaining capacity of the bins, and a combination of dynamic adjustment and an exponentially decaying factor to assign scores to each bin to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.4)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating a novel combination of the utilization ratio, dynamic adjustment, and a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the utilization ratio, dynamic adjustment, and an exponentially decaying factor while also considering the logarithm of the item size and exponential of the remaining capacity of the bins, ultimately facilitating the selection of the bin with the maximum score for item assignment by using a modified scoring function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, item size, and utilization ratio to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2.5), (1 - remaining_capacity / bins) * np.sqrt(bins - item + 1) + 0.6, (1 - remaining_capacity / bins) * np.sqrt(bins - item + 1) + 0.4)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm aims to optimize item distribution by leveraging the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm uses a combination of utilization ratio, sigmoid function, and a modified logarithmic factor based on item size and remaining capacity of the bins to assign scores to each bin for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n sigmoid_function = 1 / (1 + np.exp(bins - item))\\n scores = (bins * 1.2) / (np.log(item + 1) + 0.5) * sigmoid_function + (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to optimize item distribution by incorporating the square root of the remaining capacity of the bins and the item size to minimize the number of used bins. It uses a modified scoring function based on the square root of the utilization ratio and a dynamic adjustment factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = utilization_ratio * np.sqrt(bins - item) + 0.5\\n scores = (2 * bins) / (np.sqrt(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/20run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the utilization ratio, a novel dynamic adjustment, and a non-linearly decaying factor, incorporating a different parameter setting to facilitate the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, item size, and utilization ratio to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.8, (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating a novel combination of the utilization ratio, dynamic adjustment, and a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a stepwise scoring function based on the utilization ratio, dynamic adjustment, and a non-linearly decaying factor to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1.5)) + 0.75, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm uses a scoring function with parameters such as utilization ratio, dynamic adjustment, and a linearly decaying factor, calculated using different parameter settings, to assign scores to each bin based on their remaining capacity, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms aim to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins, using a scoring function based on utilization ratio, dynamic adjustment, and an exponentially decaying factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by combining the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin and facilitate the selection of the bin with the maximum score for item assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (item) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will aim to optimize item distribution by incorporating the remaining capacity of the bins, item size, and the distance between the item size and the bin capacity to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor with different parameter settings to the original algorithm. \\n\\nPython code for the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8\\n scores = (bins) / (np.exp((bins - item)**0.7) + 0.05) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, considering the rest capacity of the bins and aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_count = len(bins)\\n scores = np.zeros(bin_count)\\n max_capacity = max(bins)\\n if np.sum(bins) == max_capacity * bin_count:\\n return scores\\n for i in range(bin_count):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = max_capacity - bins[i]\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score in each step, where the score is calculated based on the bin's rest capacity and the item's size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n scores[i] = bins[i] - item\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the score for each bin by dividing the rest capacity of the bin by the item size and subtracting one if the rest capacity is equal to the maximum capacity, and then returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores = np.where(bins == np.max(bins), scores - 1, scores)\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: initialize an empty Numpy array called 'scores' with the same length as the 'bins' array, iterate over each bin capacity in 'bins', and calculate the score for each bin by dividing the bin capacity by the item size, and assigning the maximum score to the corresponding index in the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n for i in range(len(bins)):\\n scores[i] = bins[i] / item\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Compute the scores for each bin by dividing the rest capacity of each bin by the item size.\\n2. Sort the scores in descending order.\\n3. Assign a score of 0 to bins with the maximum capacity.\\n4. Return the scores array.\\n\\nPython function implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n sorted_scores = np.sort(scores)[::-1]\\n max_capacity = np.max(bins)\\n \\n sorted_scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"My new algorithm computes the scores for each bin by dividing the sum of the rest capacities of all bins by the product of the item size and the number of bins, subtracting the rest capacity of each bin from this value, and then taking the exponent of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n num_bins = len(bins)\\n scores = np.exp((total_capacity / (item * num_bins)) - (bins / item))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the scores for each bin by summing the squares of the rest capacities of all bins, subtracting the sum of the rest capacities of the bins divided by the item size, and then taking the square root of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin based on a combination of the rest capacity and the ratio of the item size to the bin capacity, then subtracts one if the rest capacity is equal to the maximum capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item) * np.divide(item, np.maximum(bins, 1))\\n scores = np.where(bins == np.max(bins), scores - 1, scores)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score in each step, where the score is calculated based on the bin's rest capacity divided by the item's size, multiplied by a factor of the bin's index divided by the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n scores[i] = (bins[i] / item) * (i / max_capacity)\\n return scores\",\n \"objective\": 0.05584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bin with the maximum score in each step, where the score is calculated based on the bin's rest capacity divided by the item's size, squared, multiplied by a factor of the bin's index divided by the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] != max_capacity:\\n scores[i] = ((bins[i] / item) ** 2) * (i / max_capacity)\\n return scores\",\n \"objective\": 0.0651,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the square of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) ** 2 + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the square of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) ** 2 + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the square of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) ** 2 + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the square of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) ** 2 + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the square of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) ** 2 + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the square root of the item size, then dividing it by the bin's index plus the bin's rest capacity, squared and multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(item)) / ((np.arange(len(bins)) + bins)**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.sqrt(np.arange(len(bins)) + 1)**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.sqrt(np.arange(len(bins)) + 1)**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then multiplying it by the inverse of the bin capacity, and finally raising it to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * (1 / bins) ** np.log(item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the scores for each bin by summing the squares of the rest capacities of all bins, subtracting the sum of the rest capacities of the bins divided by the item size, and then taking the square root of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin based on a combination of the rest capacity and the ratio of the item size to the bin capacity, then subtracts one if the rest capacity is equal to the maximum capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item) * np.divide(item, np.maximum(bins, 1))\\n scores = np.where(bins == np.max(bins), scores - 1, scores)\\n return scores\",\n \"objective\": 0.0498,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, then dividing it by the sum of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1 + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the square of the bin's rest capacity by the difference between the item size and the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(bins) / (item - bins)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_26.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the square of the bin's rest capacity by the difference between the item size and the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(bins) / (item - bins)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_27.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the square of the bin's rest capacity by the difference between the item size and the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.square(bins) / (item - bins)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_28.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index squared and the bin's rest capacity squared plus a small constant epsilon, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity plus a small constant epsilon, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item) - np.log(bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_29.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index squared and the bin's rest capacity squared plus a small constant epsilon, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity plus a small constant epsilon, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item) - np.log(bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.cbrt(item)) / (np.arange(len(bins))**2 * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then multiplying it by the inverse of the bin capacity, and finally raising it to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * (1 / bins) ** np.log(item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then subtracting the logarithm of the bin capacity, and finally raising it to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - np.log(bins) ** (np.sqrt(item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the scores for each bin by summing the squares of the rest capacities of all bins, subtracting the sum of the rest capacities of the bins divided by the item size, and then taking the square root of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_30.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index squared and the bin's rest capacity squared plus a small constant epsilon, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity plus a small constant epsilon, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item) - np.log(bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the element-wise product of the bin's rest capacity and the cube root of the item size, then dividing it by the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (item**(1/3))) / (np.square(np.arange(len(bins))) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_31.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index squared and the bin's rest capacity squared plus a small constant epsilon, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity plus a small constant epsilon, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item) - np.log(bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by multiplying the bin's rest capacity with the logarithm of the item size, then dividing it by the square root of the bin's index squared, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(item)) / ((np.arange(len(bins)) + 1) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_32.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index squared and the bin's rest capacity squared plus a small constant epsilon, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity plus a small constant epsilon, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item) - np.log(bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_33.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_34.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_35.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_36.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_37.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_38.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * np.log(item / bins))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2) * (np.log(item / bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_39.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(len(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the exponential of the logarithm of the item size divided by the rest capacity of each bin, then multiplying it by the inverse of the bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(item) / bins) * (1 / bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then subtracting the logarithm of the bin capacity, and finally raising it to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - np.log(bins) ** (np.sqrt(item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the scores for each bin by summing the squares of the rest capacities of all bins, subtracting the sum of the rest capacities of the bins divided by the item size, and then taking the square root of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_40.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared, the bin's rest capacity squared, and the absolute difference between the bin's rest capacity and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + np.abs(bins - np.max(bins))) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(len(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_41.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm takes the product of the bin's rest capacity and the square root of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's rest capacity squared, and the bin's index squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(item)) / ((np.max(bins)**2 + bins**2 + np.arange(len(bins))**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, dividing it by the sum of the bin's index squared and the bin's rest capacity squared, adding a small constant epsilon to the denominator, multiplied by the logarithm of the item size divided by the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n scores = (bins * item) / ((np.arange(len(bins))**2 + bins**2 + epsilon) * (np.log(item / bins) + epsilon))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_42.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm takes the product of the bin's rest capacity and the square root of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's rest capacity squared, and the bin's index squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.sqrt(item)) / ((np.max(bins)**2 + bins**2 + np.arange(len(bins))**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm takes the product of the bin's rest capacity and the square root of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's rest capacity squared, and the bin's index squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((bins**2 + np.arange(len(bins))**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_43.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the square of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's index squared, and the bin's rest capacity squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item**2) / ((np.max(bins)**2 + np.arange(len(bins))**2 + bins**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm takes the product of the bin's rest capacity and the square root of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's rest capacity squared, and the bin's index squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((bins**2 + np.arange(len(bins))**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_44.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the square of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's index squared, and the bin's rest capacity squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item**2) / ((np.max(bins)**2 + np.arange(len(bins))**2 + bins**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm takes the product of the bin's rest capacity and the square root of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's rest capacity squared, and the bin's index squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((bins**2 + np.arange(len(bins))**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_45.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the log of the item size minus the log of the bin's rest capacity, multiplied by the exponential function of the ratio between the bin's index and the square root of the bin's rest capacity. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.log(item) - np.log(bins)) * np.exp(np.arange(len(bins)) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the square of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's index squared, and the bin's rest capacity squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item**2) / ((np.max(bins)**2 + np.arange(len(bins))**2 + bins**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_46.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the log of the item size minus the log of the bin's rest capacity, multiplied by the exponential function of the ratio between the bin's index and the square root of the bin's rest capacity. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.log(item) - np.log(bins)) * np.exp(np.arange(len(bins)) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the square of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's index squared, and the bin's rest capacity squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item**2) / ((np.max(bins)**2 + np.arange(len(bins))**2 + bins**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_47.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the log of the item size minus the log of the bin's rest capacity, multiplied by the exponential function of the ratio between the bin's index and the square root of the bin's rest capacity. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.log(item) - np.log(bins)) * np.exp(np.arange(len(bins)) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the square of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's index squared, and the bin's rest capacity squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item**2) / ((np.max(bins)**2 + np.arange(len(bins))**2 + bins**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_48.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the log of the item size minus the log of the bin's rest capacity, multiplied by the exponential function of the ratio between the bin's index and the square root of the bin's rest capacity. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.log(item) - np.log(bins)) * np.exp(np.arange(len(bins)) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the square of the item size, dividing it by the sum of the square of the maximum capacity of the bins, the bin's index squared, and the bin's rest capacity squared, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item**2) / ((np.max(bins)**2 + np.arange(len(bins))**2 + bins**2) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_49.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the log of the item size minus the log of the bin's rest capacity, multiplied by the exponential function of the ratio between the bin's index and the square root of the bin's rest capacity. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.log(item) - np.log(bins)) * np.exp(np.arange(len(bins)) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the item size divided by the rest capacity of each bin, then subtracting the logarithm of the bin capacity from it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then subtracting the logarithm of the bin capacity, and finally raising it to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - np.log(bins) ** (np.sqrt(item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes the scores for each bin by summing the squares of the rest capacities of all bins, subtracting the sum of the rest capacities of the bins divided by the item size, and then taking the square root of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_50.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the log of the item size minus the log of the bin's rest capacity, multiplied by the exponential function of the ratio between the bin's index and the square root of the bin's rest capacity. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.log(item) - np.log(bins)) * np.exp(np.arange(len(bins)) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_51.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the log of the item size minus the log of the bin's rest capacity, multiplied by the exponential function of the ratio between the bin's index and the square root of the bin's rest capacity. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (np.log(item) - np.log(bins)) * np.exp(np.arange(len(bins)) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_52.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_53.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_54.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_55.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_56.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index plus one multiplied by the square root of the bin's rest capacity plus one, multiplied by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / ((np.sqrt(np.arange(len(bins))) + 1) * (np.sqrt(bins) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_57.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_58.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / item * (np.exp(np.arange(len(bins)) / bins) / (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_59.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size, using various mathematical functions and operations.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity multiplied by the item size, divided by the exponential of the bin's index plus the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) * item) / (np.exp(np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the item size divided by the rest capacity of each bin, then subtracting the logarithm of the bin capacity from it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then subtracting the logarithm of the bin capacity, and finally raising it to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - np.log(bins) ** (np.sqrt(item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by dividing the square root of the rest capacity of each bin by the item size, subtracting the logarithm of the bin capacity, multiplying it by the square root of the item size, and finally dividing it by the item size itself.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / item) - np.log(bins) * (np.sqrt(item) / item)\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_60.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size, using various mathematical functions and operations.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity multiplied by the item size, divided by the exponential of the bin's index plus the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) * item) / (np.exp(np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_61.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size, using various mathematical functions and operations.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity multiplied by the item size, divided by the exponential of the bin's index plus the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) * item) / (np.exp(np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_62.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size, using various mathematical functions and operations.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity multiplied by the item size, divided by the exponential of the bin's index plus the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) * item) / (np.exp(np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_63.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size, using various mathematical functions and operations.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity multiplied by the item size, divided by the exponential of the bin's index plus the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) * item) / (np.exp(np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_64.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the bin's rest capacity minus the item size, divided by the item size, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * (np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, divided by the exponential of the bin's index plus the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.exp(np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_65.json", "content": "[\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the item size, divided by the exponential of the bin's index plus the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.exp(np.arange(len(bins)) + bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_66.json", "content": "[\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the absolute difference between the bin's rest capacity and the item size, then multiply it by the exponential of the bin's index divided by the item size plus one, and finally divide it by the logarithm of the absolute difference plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.abs(bins - item) * np.exp(np.arange(len(bins)) / (item + 1))) / (np.log(np.abs(bins - item) + 1))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_67.json", "content": "[\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the absolute difference between the bin's rest capacity and the item size, then multiply it by the exponential of the bin's index divided by the item size plus one, and finally divide it by the logarithm of the absolute difference plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.abs(bins - item) * np.exp(np.arange(len(bins)) / (item + 1))) / (np.log(np.abs(bins - item) + 1))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_68.json", "content": "[\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the absolute difference between the bin's rest capacity and the item size, then multiply it by the exponential of the bin's index divided by the item size plus one, and finally divide it by the logarithm of the absolute difference plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.abs(bins - item) * np.exp(np.arange(len(bins)) / (item + 1))) / (np.log(np.abs(bins - item) + 1))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_69.json", "content": "[\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the absolute difference between the bin's rest capacity and the item size, then multiply it by the exponential of the bin's index divided by the item size plus one, and finally divide it by the logarithm of the absolute difference plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.abs(bins - item) * np.exp(np.arange(len(bins)) / (item + 1))) / (np.log(np.abs(bins - item) + 1))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the item size divided by the rest capacity of each bin, then subtracting the logarithm of the bin capacity from it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then subtracting the logarithm of the bin capacity, and finally raising it to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - np.log(bins) ** (np.sqrt(item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by dividing the square root of the rest capacity of each bin by the item size, subtracting the logarithm of the bin capacity, multiplying it by the square root of the item size, and finally dividing it by the item size itself.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / item) - np.log(bins) * (np.sqrt(item) / item)\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_70.json", "content": "[\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the absolute difference between the bin's rest capacity and the item size, then multiply it by the exponential of the bin's index divided by the item size plus one, and finally divide it by the logarithm of the absolute difference plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.abs(bins - item) * np.exp(np.arange(len(bins)) / (item + 1))) / (np.log(np.abs(bins - item) + 1))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, my new algorithm calculates the score for each bin by taking the exponential function of the ratio between the bin's rest capacity and the item size, dividing it by the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the natural logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / item) / (np.arange(len(bins)) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_71.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the absolute difference between the bin's rest capacity and the item size, then multiply it by the exponential of the bin's index divided by the item size plus one, and finally divide it by the logarithm of the absolute difference plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.abs(bins - item) * np.exp(np.arange(len(bins)) / (item + 1))) / (np.log(np.abs(bins - item) + 1))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_72.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the absolute difference between the bin's rest capacity and the item size, then multiply it by the exponential of the bin's index divided by the item size plus one, and finally divide it by the logarithm of the absolute difference plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.abs(bins - item) * np.exp(np.arange(len(bins)) / (item + 1))) / (np.log(np.abs(bins - item) + 1))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_73.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_74.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_75.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_76.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_77.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin by taking the cosine function of the ratio between the bin's rest capacity and the item size, dividing it by the square root of the bin's index multiplied by the square root of the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / item) / (np.sqrt(np.arange(len(bins))) * np.sqrt(bins) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_78.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the natural logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) * (np.exp(np.arange(len(bins)) / (bins + 1))) / ((np.log(item + 1) - np.log(bins + 1)) * np.log(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The main steps of the new algorithm are as follows: \\n1. Calculate the square root of the bin's rest capacity minus the item size.\\n2. Divide the result by the item size.\\n3. Multiply the above result by the exponential of the bin's index divided by the bin's rest capacity plus one.\\n4. Divide the above result by the logarithm of the item size minus the logarithm of the bin's rest capacity plus one.\\n5. Return the scores as a Numpy array.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item) / item * np.exp(np.arange(len(bins)) / (bins + 1)) / (np.log(item) - np.log(bins + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_79.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the natural logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) * (np.exp(np.arange(len(bins)) / (bins + 1))) / ((np.log(item + 1) - np.log(bins + 1)) * np.log(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the item size divided by the bin's rest capacity, multiplied by the sum of the bin's index and the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the logarithm of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(item) / bins) * ((np.arange(len(bins)) + np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the item size divided by the rest capacity of each bin, then subtracting the logarithm of the bin capacity from it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by dividing the rest capacity of each bin by the item size, then subtracting the logarithm of the bin capacity, and finally raising it to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - np.log(bins) ** (np.sqrt(item))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the exponential of the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the natural logarithm of the item size minus the natural logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.exp(bins * item)) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_80.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, multiplied by the sum of the square root of the bin's index and the logarithm of the bin's rest capacity, divided by the square root of the item size plus one minus the square root of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * ((np.sqrt(np.arange(len(bins))) + np.log(bins)) / (np.sqrt(item + 1) - np.sqrt(bins + 1)))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, multiplied by the exponential of the bin's index divided by the bin's rest capacity plus one, divided by the natural logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) * (np.exp(np.arange(len(bins)) / (bins + 1))) / ((np.log(item + 1) - np.log(bins + 1)) * np.log(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin by taking the product of the bin's rest capacity divided by the item size, raised to the power of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one, then multiplied by the natural logarithm of the bin's rest capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / item) ** (np.arange(len(bins)) / np.sqrt(bins))) / ((np.log(item + 1) - np.log(bins + 1)) * (np.log(bins)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin by taking the square root of the item size divided by the bin's rest capacity, multiplied by the sum of the bin's index and the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the logarithm of the bin's rest capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(item) / bins) * ((np.arange(len(bins)) + np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate the score for each bin based on the ratio between the bin's rest capacity and the item size.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin by taking the logarithm of the bin's rest capacity divided by the item size, multiplied by the exponential of the bin's index divided by the square root of the bin's rest capacity, divided by the logarithm of the item size plus one minus the natural logarithm of the bin's rest capacity plus one.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / item) * (np.exp(np.arange(len(bins)) / np.sqrt(bins)) / (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the bin's index and the difference between the maximum capacity of the bins and the bin's rest capacity, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + (np.max(bins) - bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.square(np.arange(len(bins))) + np.max(bins)) * (np.log(item) - np.log(bins)))\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by dividing the product of the bin's rest capacity and the item size by the sum of the squares of the bin's index and the maximum capacity of the bins, multiplied by the logarithm of the item size minus the logarithm of the bin's rest capacity, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.arange(len(bins)) + 1) * (np.log(item + 1) - np.log(bins + 1)))\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the score for each bin by taking the product of the bin's rest capacity and the reciprocal of the item size, subtracts the square root of the bin's index, and finally returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / item) - np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin by taking the square root of the item size divided by the rest capacity of each bin, then subtracting the logarithm of the bin capacity from it.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nAlgorithm:\\n- Calculate the free capacities of each bin by subtracting the item size from the rest capacities of feasible bins.\\n- If the rest capacity of a bin is equal to the maximum capacity, assign a score of 0 to that bin.\\n- If the rest capacity of a bin is less than the maximum capacity, assign a score based on the formula: score = (maximum capacity - rest capacity) / maximum capacity.\\n- Return the array of scores.\\n\\nPython function:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins)) # Initialize the scores array with zeros\\n \\n max_capacity = np.max(bins) # Maximum capacity among the feasible bins\\n \\n for i in range(len(bins)):\\n rest_capacity = bins[i] - item\\n \\n if rest_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - rest_capacity) / max_capacity\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nAlgorithm:\\n\\n1. Initialize an empty Numpy array named 'scores' with the same length as the input 'bins'.\\n\\n2. Check if any bin has a capacity equal to the maximum capacity, if yes, assign a score of 0 to that bin in 'scores'.\\n\\n3. For the remaining bins, calculate the scores using a formula that takes into account the rest capacity of the bin and the size of the current item. \\n Assign the calculated score to the corresponding bin in 'scores'.\\n\\n4. Return 'scores' as the output of the function.\\n\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n scores[remaining_bins] = (bins[remaining_bins] - item) / (max_capacity - item)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm loops through each bin and calculates the score for each bin by dividing the remaining capacity of the bin by the size of the item, and assigns the maximum score to the corresponding bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] // item\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns each item to the bin with the maximum score at each step, considering the rest capacity of the bins. The score of a bin is calculated as the difference between the remaining capacity and the size of the item, divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.max(bins)\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm assigns each item to the bin with the maximum score, taking into consideration the capacity limit of each bin. It aims to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != item # Filter out bins with equal capacity to the item size\\n scores[mask] = bins[mask] - item # Compute scores for the remaining bins\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the remaining capacity to the item size raised to the power of the negative logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item)**(-np.log(item))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the inverse of the remaining capacity of the bin raised to the power of the reciprocal of the item size, giving higher scores to bins with smaller remaining capacity and larger item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n remaining_capacity = bins[bins != np.max(bins)]\\n scores[bins != np.max(bins)] = 1 / (remaining_capacity ** (1/item))\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity and the square root of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n max_capacity = np.max(bins)\\n\\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n\\n remaining_bins = np.where(bins != max_capacity)[0]\\n scores[remaining_bins] = np.log(bins[remaining_bins]) + np.sqrt(1 / item)\\n\\n return scores\",\n \"objective\": 0.04558,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea found in the provided algorithms is to assign scores to bins based on a combination of the remaining capacity and the size of the item.\\n\\nBased on this idea, the new algorithm assigns scores to bins based on the product of the natural logarithm of the remaining capacity and the square root of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities.\\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n scores[remaining_bins] = np.log(bins[remaining_bins]) * np.sqrt(1 / item)\\n \\n return scores\",\n \"objective\": 0.05232,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity and the cosine of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = bins == max_capacity\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = bins != max_capacity\\n scores[remaining_bins] = np.sin(bins[remaining_bins]) + np.cos(1 / item)\\n \\n return scores\",\n \"objective\": 0.05312,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_log_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_log_item_size\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description of new algorithm:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the reciprocal of the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_item_size = np.reciprocal(np.sqrt(item))\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) * reciprocal_item_size\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the product of the remaining capacity divided by the item size, the logarithm of the reciprocal of the item size, and the square root of the item size.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (bins[remaining_bins] / item) * np.log(1 / item) * np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (np.sqrt(bins[remaining_bins] / item)) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_log_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_log_item_size\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the square root of the remaining capacity to the item size, multiplied by the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n logarithm_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item * logarithm_bin_size\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_item_size\\n\\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description of new algorithm:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the reciprocal of the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_item_size = np.reciprocal(np.sqrt(item))\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) * reciprocal_item_size\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_log_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_log_item_size\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the square root of the remaining capacity to the item size, multiplied by the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n logarithm_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item * logarithm_bin_size\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_item_size\\n\\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity divided by the item size plus the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n remaining_divided_item = remaining_capacity / item\\n sqrt_item_size = np.sqrt(item)\\n\\n scores[remaining_bins] = remaining_divided_item + sqrt_item_size\\n\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_log_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_log_item_size\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the square root of the remaining capacity to the item size, multiplied by the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n logarithm_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item * logarithm_bin_size\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_item_size\\n\\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns scores to bins based on the product of the remaining capacity divided by the item size plus the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n remaining_divided_item = remaining_capacity / item\\n sqrt_item_size = np.sqrt(item)\\n\\n scores[remaining_bins] = remaining_divided_item + sqrt_item_size\\n\\n return scores\",\n \"objective\": 0.03723,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_log_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_log_item_size\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n scores[remaining_bins] = np.log1p(remaining_capacity) / np.log1p(item)\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio of the square root of the remaining capacity to the item size, multiplied by the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n logarithm_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item * logarithm_bin_size\\n\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_log_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_log_item_size\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n scores[remaining_bins] = np.log1p(remaining_capacity) / np.log1p(item)\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_log_item_size = np.reciprocal(np.log(item))\\n\\n scores[remaining_bins] = np.log(remaining_capacity) * reciprocal_log_item_size\\n\\n return scores\",\n \"objective\": 0.03089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity divided by the item size and the reciprocal of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n scores[remaining_bins] = np.log1p(remaining_capacity) / np.log1p(item)\\n\\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(bins[remaining_bins]) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for bins based on their remaining capacity and the size of the item.\\n\\nThe new algorithm assigns scores to bins based on the difference between the logarithm of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = log_remaining_capacity / sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the logarithm of the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_item_size = np.log(item)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = (np.log(remaining_capacity) / log_item_size) + log_bin_size\\n\\n return scores\",\n \"objective\": 0.02415,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(bins[remaining_bins]) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the logarithm of the item size and the logarithm of the bin size, and also takes into account the square root of the inverse of the number of remaining bins, giving higher scores to bins with larger remaining capacity, smaller item sizes, and a lower number of remaining bins.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_item_size = np.log(item)\\n log_bin_size = np.log(bins[remaining_bins])\\n sqrt_inv_remaining_bins = np.sqrt(1 / len(remaining_bins))\\n\\n scores[remaining_bins] = (log_remaining_capacity / log_item_size) + log_bin_size + sqrt_inv_remaining_bins\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + 1e-10)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the inverse of the remaining capacity of the bin raised to the power of the reciprocal of the item size, giving higher scores to bins with smaller remaining capacity and larger item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on a combination of the remaining capacity and the size of the item.\\n\\nBased on this idea, the new algorithm assigns scores to bins based on the product of the natural logarithm of the remaining capacity and the exponentiated reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on the product of the natural logarithm of the remaining capacity and the exponentiated reciprocal of the item size.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n scores[remaining_bins] = np.log(bins[remaining_bins]) * np.exp(1 / item)\\n \\n return scores\",\n \"objective\": 0.04477,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the logarithm of the remaining capacity and the square root of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n max_capacity = np.max(bins)\\n\\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n\\n remaining_bins = np.where(bins != max_capacity)[0]\\n scores[remaining_bins] = np.log(bins[remaining_bins]) + np.sqrt(1 / item)\\n\\n return scores\",\n \"objective\": 0.04558,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on a combination of the remaining capacity and the size of the item.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the ratio of the square root of the remaining capacity to the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) / item\\n \\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the logarithm of the item size and the logarithm of the bin size, and also takes into account the square root of the inverse of the number of remaining bins, giving higher scores to bins with larger remaining capacity, smaller item sizes, and a lower number of remaining bins.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_item_size = np.log(item)\\n log_bin_size = np.log(bins[remaining_bins])\\n sqrt_inv_remaining_bins = np.sqrt(1 / len(remaining_bins))\\n\\n scores[remaining_bins] = (log_remaining_capacity / log_item_size) + log_bin_size + sqrt_inv_remaining_bins\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the logarithm of the item size and the logarithm of the bin size, and also takes into account the square root of the inverse of the number of remaining bins, giving higher scores to bins with larger remaining capacity, smaller item sizes, and a lower number of remaining bins.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_item_size = np.log(item)\\n log_bin_size = np.log(bins[remaining_bins])\\n sqrt_inv_remaining_bins = np.sqrt(1 / len(remaining_bins))\\n\\n scores[remaining_bins] = (log_remaining_capacity / log_item_size) + log_bin_size + sqrt_inv_remaining_bins\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the logarithm of the item size and the logarithm of the bin size, and also takes into account the square root of the inverse of the number of remaining bins, giving higher scores to bins with larger remaining capacity, smaller item sizes, and a lower number of remaining bins.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_item_size = np.log(item)\\n log_bin_size = np.log(bins[remaining_bins])\\n sqrt_inv_remaining_bins = np.sqrt(1 / len(remaining_bins))\\n\\n scores[remaining_bins] = (log_remaining_capacity / log_item_size) + log_bin_size + sqrt_inv_remaining_bins\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the logarithm of the item size and the logarithm of the bin size, and also takes into account the square root of the inverse of the number of remaining bins, giving higher scores to bins with larger remaining capacity, smaller item sizes, and a lower number of remaining bins.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_item_size = np.log(item)\\n log_bin_size = np.log(bins[remaining_bins])\\n sqrt_inv_remaining_bins = np.sqrt(1 / len(remaining_bins))\\n\\n scores[remaining_bins] = (log_remaining_capacity / log_item_size) + log_bin_size + sqrt_inv_remaining_bins\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.log(remaining_capacity) / item + np.log(bins[remaining_bins])\\n\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the sum of the logarithm of the remaining capacity divided by the logarithm of the item size and the logarithm of the bin size, and also takes into account the square root of the inverse of the number of remaining bins, giving higher scores to bins with larger remaining capacity, smaller item sizes, and a lower number of remaining bins.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_remaining_capacity = np.log(remaining_capacity)\\n log_item_size = np.log(item)\\n log_bin_size = np.log(bins[remaining_bins])\\n sqrt_inv_remaining_bins = np.sqrt(1 / len(remaining_bins))\\n\\n scores[remaining_bins] = (log_remaining_capacity / log_item_size) + log_bin_size + sqrt_inv_remaining_bins\\n\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_26.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is assigning scores to bins based on the combination of the remaining capacity divided by the item size and some function of the item and/or bin size.\\n\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size, the square root of the logarithm of the item size, and the square root of the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item and bin sizes.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n sqrt_log_bin_size = np.sqrt(np.log(bins[remaining_bins]))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size + sqrt_log_bin_size\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size and the square root of the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n log_item_size = np.log(item)\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) / item + np.sqrt(log_item_size)\\n\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_27.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```py\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is assigning scores to bins based on the combination of the remaining capacity divided by the item size and some function of the item and/or bin size.\\n\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size, the square root of the logarithm of the item size, and the square root of the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item and bin sizes.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n sqrt_log_bin_size = np.sqrt(np.log(bins[remaining_bins]))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size + sqrt_log_bin_size\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_28.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```py\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is assigning scores to bins based on the combination of the remaining capacity divided by the item size and some function of the item and/or bin size.\\n\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size, the square root of the logarithm of the item size, and the square root of the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item and bin sizes.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n sqrt_log_bin_size = np.sqrt(np.log(bins[remaining_bins]))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size + sqrt_log_bin_size\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_29.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```py\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is assigning scores to bins based on the combination of the remaining capacity divided by the item size and some function of the item and/or bin size.\\n\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size, the square root of the logarithm of the item size, and the square root of the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item and bin sizes.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n sqrt_log_bin_size = np.sqrt(np.log(bins[remaining_bins]))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size + sqrt_log_bin_size\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(item) / (bins + 1e-10)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n My new algorithm assigns scores to bins based on the weighted sum of the difference between the remaining capacity and the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities and applying a logarithmic transformation to the scores for a wider range of values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n \\n weight = 1 / (np.log(bins) + 1e-10)\\n scores[remaining_bins] = weight[remaining_bins] * (max_capacity - bins[remaining_bins] - item)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the inverse of the remaining capacity of the bin raised to the power of the reciprocal of the item size, giving higher scores to bins with smaller remaining capacity and larger item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the ratio of the remaining capacity to the square of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities.\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n scores[remaining_bins] = bins[remaining_bins] / (item ** 2)\\n \\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_30.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```py\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is assigning scores to bins based on the combination of the remaining capacity divided by the item size and some function of the item and/or bin size.\\n\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size, the square root of the logarithm of the item size, and the square root of the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item and bin sizes.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n sqrt_log_bin_size = np.sqrt(np.log(bins[remaining_bins]))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size + sqrt_log_bin_size\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_31.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```py\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is assigning scores to bins based on the combination of the remaining capacity divided by the item size and some function of the item and/or bin size.\\n\\nThe new algorithm assigns scores to bins based on the sum of the square root of the remaining capacity divided by the item size, the square root of the logarithm of the item size, and the square root of the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item and bin sizes.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n sqrt_log_item_size = np.sqrt(np.log(item))\\n sqrt_log_bin_size = np.sqrt(np.log(bins[remaining_bins]))\\n\\n scores[remaining_bins] = sqrt_remaining_capacity / item + sqrt_log_item_size + sqrt_log_bin_size\\n\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_32.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n # Normalize remaining_capacity\\n normalized_remaining_capacity = remaining_capacity / np.max(bins)\\n\\n tanh_remaining_capacity = np.tanh(normalized_remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = tanh_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n # Simplifications\\n normalized_remaining_capacity = remaining_capacity / 100\\n tanh_remaining_capacity = np.tanh(np.clip(normalized_remaining_capacity, -10, 10))\\n log_bin_size = np.log1p(bins[remaining_bins])\\n\\n scores[remaining_bins] = tanh_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_33.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n # Simplifications\\n normalized_remaining_capacity = remaining_capacity / 100\\n tanh_remaining_capacity = np.tanh(np.clip(normalized_remaining_capacity, -10, 10))\\n log_bin_size = np.log1p(bins[remaining_bins])\\n\\n scores[remaining_bins] = tanh_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_34.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n # Simplifications\\n normalized_remaining_capacity = remaining_capacity / 100\\n tanh_remaining_capacity = np.tanh(np.clip(normalized_remaining_capacity, -10, 10))\\n log_bin_size = np.log1p(bins[remaining_bins])\\n\\n scores[remaining_bins] = tanh_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_35.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n\\n # Simplifications\\n normalized_remaining_capacity = remaining_capacity / 100\\n tanh_remaining_capacity = np.tanh(np.clip(normalized_remaining_capacity, -10, 10))\\n log_bin_size = np.log1p(bins[remaining_bins])\\n\\n scores[remaining_bins] = tanh_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_36.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n normalized_remaining_capacity = (bins[remaining_bins] - item) / 100\\n \\n # Revised simplifications\\n tanh_remaining_capacity = np.tanh(np.clip(normalized_remaining_capacity, -10, 10))\\n log_bin_size = np.log1p(bins[remaining_bins])\\n\\n scores[remaining_bins] = tanh_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_37.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n log_bins = np.log(bins) # Calculate logarithm only once\\n \\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bins[remaining_bins]\\n\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n normalized_remaining_capacity = (bins[remaining_bins] - item) / 100\\n \\n # Revised simplifications\\n tanh_remaining_capacity = np.tanh(np.clip(normalized_remaining_capacity, -10, 10))\\n log_bin_size = np.log1p(bins[remaining_bins])\\n\\n scores[remaining_bins] = tanh_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_38.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_39.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log1p(item) / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n My new algorithm assigns scores to bins based on the weighted sum of the difference between the remaining capacity and the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities and applying a logarithmic transformation to the scores for a wider range of values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n \\n weight = 1 / (np.log(bins) + 1e-10)\\n scores[remaining_bins] = weight[remaining_bins] * (max_capacity - bins[remaining_bins] - item)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to bins based on the remaining capacity and the item size, giving higher scores to bins with either larger remaining capacity or smaller item sizes.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the logarithm of the remaining capacity divided by the item size raised to the power of the natural logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while promoting a wider range of score values with the natural logarithm.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.log(bins[remaining_bins]) / (item ** np.log(item))\\n\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to bins based on the inverse of the remaining capacity of the bin raised to the power of the reciprocal of the item size, giving higher scores to bins with smaller remaining capacity and larger item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n \\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_40.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_41.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_42.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_43.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_44.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_45.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_46.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_47.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_48.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_49.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (np.sqrt(bins[remaining_bins] / item)) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to bins based on the remaining capacity and the item size, giving higher scores to bins with either larger remaining capacity or smaller item sizes.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the difference between the square of the remaining capacity and the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities and applying a logarithmic transformation to the scores for a wider range of values. \\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n \\n scores[remaining_bins] = (max_capacity - bins[remaining_bins]) - item\\n \\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign scores to bins based on a combination of the remaining capacity and the item size.\\n\\nNew algorithm: The new algorithm assigns scores to bins based on a weighted sum of the difference between the remaining capacity and the item size, while taking into account the logarithmic transformation of both the capacity and item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, promoting a wider range of values for more informed assignment decisions.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n \\n weight = 1 / (np.log(bins+1) + np.log(item+1) + 1e-10)\\n scores[remaining_bins] = weight[remaining_bins] * (max_capacity - bins[remaining_bins] - item)\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_50.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins >= item\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_51.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_52.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n tanh_remaining_capacity = np.tanh(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(remaining_capacity) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_53.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_54.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_55.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the sine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n sin_remaining_capacity = np.sin(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = sin_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_56.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_57.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_58.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n eps = 1e-8\\n inv_remaining_capacity = 1.0 / (remaining_capacity + eps)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_59.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (np.sqrt(bins[remaining_bins] / item)) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (bins[remaining_bins] / item) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to bins based on the remaining capacity and the item size, giving higher scores to bins with either larger remaining capacity or smaller item sizes.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the difference between the square of the remaining capacity and the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities and applying a logarithmic transformation to the scores for a wider range of values. \\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n \\n scores[remaining_bins] = (max_capacity - bins[remaining_bins]) - item\\n \\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_60.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n inv_remaining_capacity = 1.0 / remaining_capacity\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_61.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_62.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_63.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_64.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_65.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_66.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_67.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_68.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_69.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (np.sqrt(bins[remaining_bins] / item)) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (bins[remaining_bins] / item) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to bins based on the remaining capacity and the item size, giving higher scores to bins with either larger remaining capacity or smaller item sizes.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the difference between the square of the remaining capacity and the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities and applying a logarithmic transformation to the scores for a wider range of values. \\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n \\n scores[remaining_bins] = max_capacity - bins[remaining_bins] - item\\n \\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_70.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n bin_scores = np.tanh(bins[remaining_bins]) / item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = bin_scores + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_71.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_72.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_73.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_74.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_75.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_76.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_77.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_78.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_79.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (np.sqrt(bins[remaining_bins] / item)) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (bins[remaining_bins] / item) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to bins based on the remaining capacity and the item size, giving higher scores to bins with either larger remaining capacity or smaller item sizes.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the difference between the square of the remaining capacity and the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes, while taking into account the relative difference between bin capacities and applying a logarithmic transformation to the scores for a wider range of values. \\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n \\n max_capacity = np.max(bins)\\n \\n zero_capacity_bins = np.where(bins == max_capacity)[0]\\n scores[zero_capacity_bins] = 0\\n \\n remaining_bins = np.where(bins != max_capacity)[0]\\n \\n scores[remaining_bins] = max_capacity - bins[remaining_bins] - item\\n \\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_80.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the inverse of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > 0\\n remaining_capacity = np.maximum(bins - item, 0)\\n inv_remaining_capacity = 1.0 / (remaining_capacity + 1e-8)\\n log_bin_size = np.where(bins > 0, np.log(bins), 0)\\n\\n scores[remaining_bins] = inv_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = 1 / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the cosine of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = bins > item\\n remaining_capacity = bins[remaining_bins] - item\\n cos_remaining_capacity = np.cos(remaining_capacity)\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = cos_remaining_capacity / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the sum of the hyperbolic tangent of the remaining capacity divided by the item size and the logarithm of the bin size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n log_bin_size = np.log(bins[remaining_bins])\\n\\n scores[remaining_bins] = np.tanh(bins[remaining_bins]) / item + log_bin_size\\n\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"Description of new algorithm:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the reciprocal of the square root of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n remaining_capacity = bins[remaining_bins] - item\\n reciprocal_item_size = np.reciprocal(np.sqrt(item))\\n\\n scores[remaining_bins] = np.sqrt(remaining_capacity) * reciprocal_item_size\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the product of the remaining capacity divided by the item size, the logarithm of the reciprocal of the item size, and the square root of the item size.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (bins[remaining_bins] / item) * np.log(1 / item) * np.sqrt(item)\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the product of the ratio of the remaining capacity to the item size and the logarithm of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity divided by the item size and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = (np.sqrt(bins[remaining_bins] / item)) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of the square root of the remaining capacity and the logarithm of the reciprocal of the item size, giving higher scores to bins with larger remaining capacity and smaller item sizes.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n\\n remaining_bins = np.where(bins > item)[0]\\n scores[remaining_bins] = np.sqrt(bins[remaining_bins]) * np.log(1 / item)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"The algorithm accepts an item and a set of bins as input and returns the scores for the bins, calculated based on their rest capacities and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = max_capacity - bins[i]\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: The algorithm assigns an item to a bin by calculating a score for each bin based on its remaining capacity. The bin with the maximum score is chosen for assignment, and the process is repeated until all items are assigned or there are no more available bins.\\nSteps:\\n1. Create an empty Numpy array named \\\"scores\\\" with the same length as \\\"bins\\\" to store the scores for each bin.\\n2. Calculate the scores for each bin by dividing its remaining capacity by the maximum remaining capacity among all bins.\\n3. Set the score of any bin with remaining capacity equal to the maximum capacity as 0.\\n4. Return the \\\"scores\\\" array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n scores[bins == max_capacity] = 0\\n scores[bins != max_capacity] = bins[bins != max_capacity] / max_capacity\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm Description:\\n- Calculate the scores for each bin based on the rest capacity.\\n- If the rest capacity of a bin equals the maximum capacity, assign a score of 0 to that bin.\\n- Otherwise, calculate the score as the difference between the rest capacity and the item size.\\n\\nMain Steps:\\n1. Create an empty array named 'scores' with the same length as the 'bins' array.\\n2. Calculate the maximum capacity by finding the maximum value in the 'bins' array.\\n3. Iterate over each bin in the 'bins' array.\\n4. If the rest capacity of the bin equals the maximum capacity, assign a score of 0 to that bin in the 'scores' array.\\n5. Otherwise, calculate the score as the difference between the rest capacity and the item size, and assign it to the corresponding index in the 'scores' array.\\n6. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] - item\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that maximizes the score of each bin and minimizes the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n feasible_bins = bins[bins > item]\\n if len(feasible_bins) == 0:\\n return scores\\n \\n max_score = max_capacity - item\\n scores[bins == max_capacity] = max_score\\n \\n for size in range(item, max_capacity):\\n bins_with_capacity = feasible_bins[feasible_bins >= size]\\n if len(bins_with_capacity) == 0:\\n break\\n scores[np.where(bins == bins_with_capacity[0])] = size\\n \\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score in each step, taking into account the rest capacity of the bins and minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.copy()\\n capacities[capacities == item] = -1\\n scores = np.divide(capacities, item)\\n scores[scores < 0] = -np.inf\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The algorithm accepts an item and a set of bins as input and returns the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot accommodate the item.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.maximum(max_capacity - bins, 0) - item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its remaining capacity and the item size.\\n\\nNew algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and the maximum capacity among all bins.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = (max_capacity - bins[i]) / (max_capacity - item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: The algorithm assigns an item to a bin by calculating a score for each bin based on its remaining capacity. The bin with the maximum score is chosen for assignment, and the process is repeated until all items are assigned or there are no more available bins.\\nSteps:\\n1. Create an empty Numpy array named \\\"scores\\\" with the same length as \\\"bins\\\" to store the scores for each bin.\\n2. Calculate the scores for each bin by dividing its remaining capacity by the maximum remaining capacity among all bins.\\n3. Set the score of any bin with remaining capacity equal to the maximum capacity as 0.\\n4. Return the \\\"scores\\\" array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculate the score for each bin based on its remaining capacity and the item size.\\n\\nNew algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and the ratio between the remaining capacity and the item size, using logarithmic operations.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n ratio = np.log(bins) / np.log(item)\\n \\n scores = np.where(ratio >= 1, np.ceil(ratio) - 1, 0)\\n \\n return scores\",\n \"objective\": 0.05574,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to a bin by calculating a score for each bin based on its remaining capacity and the ratio of the remaining capacity to the size of the item. The bin with the maximum score is chosen for assignment, and the process is repeated until all items are assigned or there are no more available bins. The main steps are:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity * (remaining_capacity / max_capacity)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - 0.1 * np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = max_capacity - bins\\n scores = remaining_capacity - item + np.arange(len(bins)) + 1.5 * (max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item - np.arange(len(bins)) + 1.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item, while also considering an additional factor based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(item) - bins) - 0.1 * np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes small remaining capacities. It also incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being empty. The algorithm further adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it applies a power transformation to the scores to further enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**1.5 * (1 - bins/max_capacity) + item / (np.arange(len(bins)) + 1)**1.5\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item - np.arange(len(bins)) + 1.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item, while also considering an additional factor based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate the score for each bin based on its remaining capacity, the item size, and additional factors such as penalties or amplification based on bin indices and the difference between the maximum remaining capacity and the current bin's capacity.\\n\\nNew algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes small remaining capacities. It also incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being empty. The algorithm further adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it applies a logarithmic transformation to the scores to further enhance the differentiation between bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**1.5 * (1 - bins/max_capacity) + item / (np.log(np.arange(len(bins)) + 1) + 1)\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(item) - bins) - 0.1 * np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes small remaining capacities. It also incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being empty. The algorithm further adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it applies a power transformation to the scores to further enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**1.5 * (1 - bins/max_capacity) + item / (np.arange(len(bins)) + 1)**1.5\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item - np.arange(len(bins)) + 1.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate the score for each bin based on its remaining capacity, the item size, and additional factors such as penalties or amplification based on bin indices and the difference between the maximum remaining capacity and the current bin's capacity.\\n\\nNew algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes small remaining capacities. It also incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being empty. The algorithm further adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it applies a logarithmic transformation to the scores to further enhance the differentiation between bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**1.5 * (1 - bins/max_capacity) + item / (np.log(np.arange(len(bins)) + 1) + 1)\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(item) - bins) - 0.1 * np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes small remaining capacities. It also incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being empty. The algorithm further adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it applies a power transformation to the scores to further enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**1.5 * (1 - bins/max_capacity) + item / (np.arange(len(bins)) + 1)**1.5\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item - np.arange(len(bins)) + 1.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full. The algorithm further applies a power transformation to the scores to enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(len(bins)) + 1)**2\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(item) - bins) - 0.1 * np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes small remaining capacities. It also incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being empty. The algorithm further adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it applies a power transformation to the scores to further enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**1.5 * (1 - bins/max_capacity) + item / (np.arange(len(bins)) + 1)**1.5\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item - np.arange(len(bins)) + 1.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full. The algorithm further applies a power transformation to the scores to enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(len(bins)) + 1)**2\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(item) - bins) - 0.1 * np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes small remaining capacities. It also incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being empty. The algorithm further adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it applies a power transformation to the scores to further enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**1.5 * (1 - bins/max_capacity) + item / (np.arange(len(bins)) + 1)**1.5\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on a combination of its remaining capacity, the item size, and the index of the bin. The algorithm then adjusts the scores based on a factor that promotes assigning items to bins with higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\\n\\nHere is the code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on remaining capacity, item size, and index of the bin\\n scores = (item - bins) * np.arange(1, len(bins)+1)\\n \\n # Amplify scores based on difference between maximum remaining capacity and current bin's capacity\\n max_capacity = np.max(bins)\\n scores = scores * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on remaining capacity and item size\\n scores = item - bins\\n \\n # Adjust scores based on index of the bin\\n scores = scores * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full. The algorithm further applies a power transformation to the scores to enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(len(bins)) + 1)**2\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on a combination of its remaining capacity, the item size, and the index of the bin. The algorithm then adjusts the scores based on a factor that promotes assigning items to bins with higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\\n\\nHere is the code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on remaining capacity, item size, and index of the bin\\n scores = (item - bins) * np.arange(1, len(bins)+1)\\n \\n # Amplify scores based on difference between maximum remaining capacity and current bin's capacity\\n max_capacity = np.max(bins)\\n scores = scores * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on remaining capacity and item size\\n scores = item - bins\\n \\n # Adjust scores based on index of the bin\\n scores = scores * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full. The algorithm further applies a power transformation to the scores to enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) * (np.max(bins) / bins)**2 + item / (np.arange(len(bins)) + 1)**2\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on a combination of its remaining capacity, the item size, and the index of the bin. The algorithm then adjusts the scores based on a factor that promotes assigning items to bins with higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\\n\\nHere is the code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on remaining capacity, item size, and index of the bin\\n scores = (item - bins) * np.arange(1, len(bins)+1)\\n \\n # Amplify scores based on difference between maximum remaining capacity and current bin's capacity\\n max_capacity = np.max(bins)\\n scores = scores * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on a combination of its remaining capacity, the item size, and the index of the bin. The algorithm then adjusts the scores based on a factor that promotes assigning items to bins with higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\\n\\nHere is the code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on remaining capacity and item size\\n scores = (item - bins) * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that promotes bins with larger remaining capacity. The algorithm then adjusts the scores based on a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full. Finally, the algorithm applies a power transformation to the scores to enhance the differentiation between bins before returning them as the final scores.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(1, len(bins) + 1))**2\\n scores = scores**2\\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = 100\\n scores = (max_capacity - bins) * (max_capacity / bins)**2 + item / (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. It also adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, it incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full. The algorithm further applies a power transformation to the scores to enhance the differentiation between bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) * (np.max(bins) / bins)**2 + item / (np.arange(len(bins)) + 1)**2\\n\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"Implementing a new algorithm with different parameter settings for the score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on the ratio between current bin's capacity and average remaining capacity\\n ratio = bins / avg_capacity\\n \\n # Amplify scores based on index, maximum remaining capacity difference, current bin's capacity, and item size\\n scores = (item - bins) * np.arange(1, len(bins)+1) * (1 + ratio) * (np.max(bins) - bins + 1) * (bins + item)\\n \\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on a combination of remaining capacity, item size, and the index of the bin.\\n\\nNew algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on the ratio between the current bin's capacity and the average remaining capacity of all bins, amplifies the scores based on the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity, and adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. \\n\\nImplemented code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on the ratio between current bin's capacity and average remaining capacity\\n ratio = bins / avg_capacity\\n \\n # Amplify scores based on index, maximum remaining capacity difference, and ratio\\n scores = (item - bins) * np.arange(1, len(bins)+1) * (1 + ratio) * (np.max(bins) - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on a combination of the remaining capacity, the item size, and the index of the bin. The algorithm then adjusts the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full. The algorithm also considers the ratio between the current bin's capacity and the average remaining capacity of all bins in the scoring process, further promoting assignment to bins with higher indices and closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on the combination of remaining capacity, item size, and index of the bin\\n scores = (item - bins) * np.arange(1, len(bins)+1)\\n \\n # Amplify scores based on difference between maximum remaining capacity and current bin's capacity\\n max_capacity = np.max(bins)\\n scores = scores * (max_capacity - bins + 1)\\n \\n # Adjust scores based on a factor that promotes assigning items to bins with higher indices\\n scores = scores * np.arange(len(bins), 0, -1)\\n \\n # Adjust scores based on the ratio between current bin's capacity and average remaining capacity\\n ratio = bins / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins by calculating a score for each bin based on the remaining capacity, the item size, and the index of the bin. It adjusts the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full. However, this algorithm gives less weight to bins that are closer to being full by using a different factor than the previous algorithm. \\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on the combination of remaining capacity, item size, and index of the bin\\n scores = (item - bins) * np.arange(1, len(bins)+1)\\n \\n # Adjust scores based on a factor that promotes assigning items to bins with higher indices\\n scores = scores * np.arange(len(bins), 0, -1)\\n \\n # Amplify scores based on difference between maximum remaining capacity and current bin's capacity\\n max_capacity = np.max(bins)\\n scores = scores * (max_capacity - bins + 1) * 2\\n \\n # Adjust scores based on the ratio between current bin's capacity and average remaining capacity\\n ratio = bins / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and the index of the bin. The algorithm then adjusts the scores based on a factor that promotes assigning items to bins with lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on remaining capacity, item size, and index of the bin\\n scores = (item - bins) * np.arange(len(bins), 0, -1)\\n \\n # Amplify scores based on difference between maximum remaining capacity and current bin's capacity\\n max_capacity = np.max(bins)\\n scores = scores * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The algorithm accepts an item and a set of bins as input and returns the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot accommodate the item.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.max(bins) - bins, 0) - item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.1 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its remaining capacity and the item size.\\n\\nNew algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and the maximum capacity among all bins.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores for each bin\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = (max_capacity - bins[i]) / (max_capacity - item)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score that considers the remaining capacity of each bin, the size of the item, and a penalty factor for bins that cannot accommodate the item. It also considers the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item - np.sqrt(np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: The algorithm assigns an item to a bin by calculating a score for each bin based on its remaining capacity. The bin with the maximum score is chosen for assignment, and the process is repeated until all items are assigned or there are no more available bins.\\nSteps:\\n1. Create an empty Numpy array named \\\"scores\\\" with the same length as \\\"bins\\\" to store the scores for each bin.\\n2. Calculate the scores for each bin by dividing its remaining capacity by the maximum remaining capacity among all bins.\\n3. Set the score of any bin with remaining capacity equal to the maximum capacity as 0.\\n4. Return the \\\"scores\\\" array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It then adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, it amplifies the scores based on the ratio between the item size and the average remaining capacity. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = scores * (1 + (np.arange(len(bins), 0, -1) / len(bins)))\\n \\n # Amplify the scores based on the ratio between the item size and the average remaining capacity\\n ratio = item / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on factors such as remaining capacity, item size, and index of the bin. These scores are then adjusted or amplified based on various factors to promote assigning items to bins with lower indices and closer to being full.\\n\\nNew Algorithm: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Implementing a new algorithm with different parameter settings for the score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on the ratio between current bin's capacity and average remaining capacity\\n ratio = bins / avg_capacity\\n \\n # Amplify scores based on index, maximum remaining capacity difference, current bin's capacity, and item size\\n scores = (item - bins) * np.arange(1, len(bins)+1) * (1 + ratio) * (np.max(bins) - bins + 1) * (bins + item)\\n \\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on factors such as remaining capacity, item size, and the index of the bin. These scores are then adjusted or amplified based on various factors to promote assigning items to bins with lower indices and closer to being full.\\n\\nNew Algorithm: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It then adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, it amplifies the scores based on the ratio between the item size and the average remaining capacity, while also incorporating a penalty factor for bins with very low remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = scores * (1 + (np.arange(len(bins), 0, -1) / len(bins)))\\n \\n # Amplify the scores based on the ratio between the item size and the average remaining capacity\\n ratio = item / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < avg_capacity / 2, 0.5, 1)\\n scores = scores * penalty\\n \\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It also incorporates an additional factor that adjusts the scores based on a weighted sum of the ratio and the difference factor, further promoting assignment to bins with higher indices and closer to being full. Additionally, it amplifies the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / avg_capacity\\n diff_factor = (np.max(bins) - bins + 1) * (1 + ratio)\\n \\n scores = (item - bins) * np.arange(1, len(bins)+1) * diff_factor\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_21.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, with a penalty factor for bins that have a difference greater than a certain threshold. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, further promoting assignment to bins with higher indices and closer to being full, while amplifying the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity and a penalty for bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n \\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n \\n # Penalty factor for bins with a difference between maximum remaining capacity and current bin's capacity divided by the item size greater than a certain threshold\\n threshold = 0.2 * np.max(bins) / item\\n diff_penalty = np.where(diff_factor > threshold, 0.8, 1)\\n scores = scores * diff_penalty\\n \\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It then adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, it amplifies the scores based on the ratio between the item size and the average remaining capacity. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = scores * (1 + (np.arange(len(bins), 0, -1) / len(bins)))\\n \\n # Amplify the scores based on the ratio between the item size and the average remaining capacity\\n ratio = item / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the maximum remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * (bins / max_capacity) * np.arange(len(bins), 0, -1) * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on factors such as remaining capacity, item size, and index of the bin. These scores are then adjusted or amplified based on various factors to promote assigning items to bins with lower indices and closer to being full.\\n\\nNew Algorithm: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Implementing a new algorithm with different parameter settings for the score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on the ratio between current bin's capacity and average remaining capacity\\n ratio = bins / avg_capacity\\n \\n # Amplify scores based on index, maximum remaining capacity difference, current bin's capacity, and item size\\n scores = (item - bins) * np.arange(1, len(bins)+1) * (1 + ratio) * (np.max(bins) - bins + 1) * (bins + item)\\n \\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_22.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, with a penalty factor for bins that have a difference greater than a certain threshold. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, further promoting assignment to bins with higher indices and closer to being full, while amplifying the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity and a penalty for bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n \\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n \\n # Penalty factor for bins with a difference between maximum remaining capacity and current bin's capacity divided by the item size greater than a certain threshold\\n threshold = 0.2 * np.max(bins) / item\\n diff_penalty = np.where(diff_factor > threshold, 0.8, 1)\\n scores = scores * diff_penalty\\n \\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It then adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, it amplifies the scores based on the ratio between the item size and the average remaining capacity. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = scores * (1 + (np.arange(len(bins), 0, -1) / len(bins)))\\n \\n # Amplify the scores based on the ratio between the item size and the average remaining capacity\\n ratio = item / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the maximum remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * (bins / max_capacity) * np.arange(len(bins), 0, -1) * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on factors such as remaining capacity, item size, and index of the bin. These scores are then adjusted or amplified based on various factors to promote assigning items to bins with lower indices and closer to being full.\\n\\nNew Algorithm: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Implementing a new algorithm with different parameter settings for the score function:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins) # Simplified step\\n \\n ratio = bins / avg_capacity\\n \\n scores = (item - bins) * np.arange(1, len(bins)+1) * (1 + ratio) * (np.max(bins) - bins + 1) * (bins + item)\\n \\n return scores\",\n \"objective\": 0.02747,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_23.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, further promoting assignment to bins with higher indices and closer to being full. The scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity and a penalty is applied for bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n \\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n \\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It then adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, it amplifies the scores based on the ratio between the item size and the average remaining capacity. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = scores * (1 + (np.arange(len(bins), 0, -1) / len(bins)))\\n \\n # Amplify the scores based on the ratio between the item size and the average remaining capacity\\n ratio = item / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the square root of the sum of all bin capacities, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of all bin capacities\\n sum_capacity = np.sum(bins)\\n \\n # Calculate the scores based on the ratio between the current bin's capacity and the square root of the sum of all bin capacities\\n ratio = bins / np.sqrt(sum_capacity)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * ratio * (np.max(bins) - bins + 1) / item\\n \\n return scores\",\n \"objective\": 0.02656,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the maximum remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * (bins / max_capacity) * np.arange(len(bins), 0, -1) * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on factors such as remaining capacity, item size, and index of the bin. These scores are then adjusted or amplified based on various factors to promote assigning items to bins with lower indices and closer to being full.\\n\\nNew Algorithm: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_24.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the score of each bin based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the square of the ratio between the current bin's capacity and the item size. Furthermore, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, and a penalty is applied for bins with very low remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n\\n # Adjust the scores based on the ratio between the current bin's capacity and the item size\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, further promoting assignment to bins with higher indices and closer to being full. The scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity and a penalty is applied for bins with very low remaining capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio) / avg_ratio)\\n scores = scores * penalty_factor\\n \\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n \\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It then adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, it amplifies the scores based on the ratio between the item size and the average remaining capacity. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = scores * (1 + (np.arange(len(bins), 0, -1) / len(bins)))\\n \\n # Amplify the scores based on the ratio between the item size and the average remaining capacity\\n ratio = item / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the square root of the sum of all bin capacities, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the sum of all bin capacities\\n sum_capacity = np.sum(bins)\\n \\n # Calculate the scores based on the ratio between the current bin's capacity and the square root of the sum of all bin capacities\\n ratio = bins / np.sqrt(sum_capacity)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * ratio * (np.max(bins) - bins + 1) / item\\n \\n return scores\",\n \"objective\": 0.02656,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the maximum remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * (bins / max_capacity) * np.arange(len(bins), 0, -1) * (max_capacity - bins + 1)\\n \\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_25.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, promoting assignment to bins with higher indices and closer to being full. Finally, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nHere is the Python implementation of the new score function:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the score of each bin based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the square of the ratio between the current bin's capacity and the item size. Furthermore, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, and a penalty is applied for bins with very low remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n\\n # Adjust the scores based on the ratio between the current bin's capacity and the item size\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, further promoting assignment to bins with higher indices and closer to being full. Finally, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio) / avg_ratio)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to bins based on a weighted combination of the ratio between the current bin's capacity and the average remaining capacity, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity. It then adjusts the scores further based on a factor that promotes assigning items to bins with higher indices and closer to being full. Finally, it amplifies the scores based on the ratio between the item size and the average remaining capacity. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the average remaining capacity of all bins\\n avg_capacity = np.mean(bins)\\n \\n # Calculate the scores based on a weighted combination of factors\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * (bins / avg_capacity) * (np.max(bins) - bins + 1)\\n \\n # Adjust the scores based on a factor that promotes assigning items to bins with higher indices and closer to being full\\n scores = scores * (1 + (np.arange(len(bins), 0, -1) / len(bins)))\\n \\n # Amplify the scores based on the ratio between the item size and the average remaining capacity\\n ratio = item / avg_capacity\\n scores = scores * (1 + ratio)\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the square root of the sum of all bin capacities, the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity, divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_capacity = np.sum(bins)\\n ratio = bins / np.sqrt(sum_capacity)\\n scores = (item - bins) * np.arange(len(bins), 0, -1) * ratio * (np.max(bins) - bins + 1) / item\\n return scores\",\n \"objective\": 0.02656,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_26.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Adjust the scores based on an additional factor that incorporates the square of the ratio between the current bin's capacity and the item size\\n scores = scores * ratio**2\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, promoting assignment to bins with higher indices and closer to being full. Finally, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores based on the ratio between the current bin's capacity and the item size, as well as on other factors such as the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. They also adjust the scores based on additional factors, amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, and apply a penalty for bins with very low remaining capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * np.sqrt(ratio) * diff_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the score of each bin based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the square of the ratio between the current bin's capacity and the item size. Furthermore, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, and a penalty is applied for bins with very low remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n\\n # Adjust the scores based on the ratio between the current bin's capacity and the item size\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the square of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor**2 * ratio\\n\\n # Adjust the scores based on an additional factor that incorporates the square of the ratio between the current bin's capacity and the item size\\n scores = scores * ratio**2\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_27.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Adjust the scores based on an additional factor that incorporates the square of the ratio between the current bin's capacity and the item size\\n scores = scores * ratio**2\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, promoting assignment to bins with higher indices and closer to being full. Finally, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores based on the ratio between the current bin's capacity and the item size, as well as on other factors such as the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. They also adjust the scores based on additional factors, amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, and apply a penalty for bins with very low remaining capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * np.sqrt(ratio) * diff_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores based on a combination of factors including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the square root of the ratio between the current bin's capacity and the item size, and a unique factor of the index of the bin combined with a power factor raised to the ratio between the current bin's capacity and the item size. The scores are further amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. A penalty is applied for bins with very low remaining capacity, and the algorithm aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n index_factor = np.arange(1, len(bins)+1) * (ratio**2)\\n scores = (item - bins) * ratio * diff_factor * np.sqrt(ratio) * index_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm adjusts the score of each bin based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the square root of the ratio between the current bin's capacity and the item size. Furthermore, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. A penalty is applied for bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * np.sqrt(ratio) * diff_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_28.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Adjust the scores based on an additional factor that incorporates the square of the ratio between the current bin's capacity and the item size\\n scores = scores * ratio**2\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, promoting assignment to bins with higher indices and closer to being full. Finally, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the index of the bin squared, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity, and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n index_factor = np.arange(1, len(bins)+1)**2\\n diff_factor = (np.max(bins) - bins) / item\\n adjustment_factor = np.exp(ratio)\\n scores = (item - bins) * ratio * index_factor * diff_factor * adjustment_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores based on the ratio between the current bin's capacity and the item size, as well as on other factors such as the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. They also adjust the scores based on additional factors, amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, and apply a penalty for bins with very low remaining capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores based on the logarithm of the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * np.log(ratio) * diff_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores based on a combination of factors including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the square root of the ratio between the current bin's capacity and the item size, and a unique factor of the index of the bin combined with a power factor raised to the ratio between the current bin's capacity and the item size. The scores are further amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. A penalty is applied for bins with very low remaining capacity, and the algorithm aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n index_factor = np.arange(1, len(bins)+1) * (ratio**2)\\n scores = (item - bins) * ratio * diff_factor * np.sqrt(ratio) * index_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_29.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the square root of the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.sqrt(np.arange(1, len(bins)+1)) * ratio * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores based on the ratio between the current bin's capacity and the item size, as well as on other factors such as the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. They also adjust the scores based on additional factors, amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, and apply a penalty for bins with very low remaining capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores based on the square of the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * ratio**2 * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Adjust the scores based on an additional factor that incorporates the square of the ratio between the current bin's capacity and the item size\\n scores = scores * ratio**2\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, promoting assignment to bins with higher indices and closer to being full. Finally, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, and applies a penalty for bins with very low remaining capacity. Additionally, it introduces a new factor that amplifies the scores based on the square of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size.\\n\\nHere's the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n amplify_factor = (np.max(bins) - bins)**2 / item**2\\n scores = (item - bins) * np.arange(1, len(bins)+1) * ratio * np.exp(ratio) * diff_factor * amplify_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The algorithm accepts an item and a set of bins as input and returns the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot accommodate the item.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.max(bins) - bins, 0) - item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.1 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score that considers the remaining capacity of each bin, the size of the item, and a penalty factor for bins that cannot accommodate the item. It also considers the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item - np.sqrt(np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm: The algorithm assigns an item to a bin by calculating a score for each bin based on its remaining capacity. The bin with the maximum score is chosen for assignment, and the process is repeated until all items are assigned or there are no more available bins.\\nSteps:\\n1. Create an empty Numpy array named \\\"scores\\\" with the same length as \\\"bins\\\" to store the scores for each bin.\\n2. Calculate the scores for each bin by dividing its remaining capacity by the maximum remaining capacity among all bins.\\n3. Set the score of any bin with remaining capacity equal to the maximum capacity as 0.\\n4. Return the \\\"scores\\\" array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins == np.max(bins)] = 0\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_30.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the square root of the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.sqrt(np.arange(1, len(bins)+1)) * ratio * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores based on the ratio between the current bin's capacity and the item size, as well as on other factors such as the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. They also adjust the scores based on additional factors, amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, and apply a penalty for bins with very low remaining capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores based on the square of the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * ratio**2 * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the square root of the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / np.max(bins)\\n scores = ratio * diff_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = (item - bins) / item\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Adjust the scores based on an additional factor that incorporates the square of the ratio between the current bin's capacity and the item size\\n scores = scores * ratio**2\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size, promoting assignment to bins with higher indices and closer to being full. Finally, the scores are amplified based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_31.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the logarithm of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * ratio * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the square root of the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.sqrt(np.arange(1, len(bins)+1)) * ratio * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores based on the ratio between the current bin's capacity and the item size, as well as on other factors such as the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. They also adjust the scores based on additional factors, amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, and apply a penalty for bins with very low remaining capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores based on the square of the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * ratio**2 * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the square root of the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / np.max(bins)\\n scores = ratio * diff_factor\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = (item - bins) / item\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores based on the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. It also incorporates an additional factor that adjusts the scores based on the square of the ratio between the current bin's capacity and the item size. This algorithm aims to assign items to bins that have both closer to average remaining capacity and closer to being full, while discouraging assignment to bins with very low remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1)**2 * diff_factor * ratio\\n\\n # Adjust the scores based on an additional factor that incorporates the square of the ratio between the current bin's capacity and the item size\\n scores = scores * ratio**2\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_32.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates scores for each bin based on the ratio between the item size and the current bin's capacity, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * np.exp(-ratio) * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the logarithm of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * ratio * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the square root of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the square root of the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.sqrt(np.arange(1, len(bins)+1)) * ratio * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores based on the ratio between the current bin's capacity and the item size, as well as on other factors such as the index of the bin and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. They also adjust the scores based on additional factors, amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, and apply a penalty for bins with very low remaining capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores based on the square of the ratio between the current bin's capacity and the item size, the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.arange(1, len(bins)+1) * ratio**2 * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_33.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates scores for each bin based on the ratio between the item size and the current bin's capacity, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * np.exp(-ratio) * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the logarithm of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * ratio * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the square root of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores based on the product of the ratio between the current bin's capacity and the item size, the square root of the index of the bin, and the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, while incorporating an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size.\\n\\nCode implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (np.max(bins) - bins) / item\\n scores = (item - bins) * np.sqrt(np.arange(1, len(bins)+1)) * ratio * diff_factor\\n\\n # Adjust the scores based on an additional factor that incorporates the exponential of the ratio between the current bin's capacity and the item size\\n scores = scores * np.exp(ratio)\\n\\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity\\n scores = scores * (1 + (1 - np.abs(ratio)))\\n\\n # Penalty factor for bins with very low remaining capacity\\n penalty = np.where(bins < item/10, 0.1, 1)\\n scores = scores * penalty\\n\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_34.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins that have more remaining capacity. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n log_ratio_factor = np.log10(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n sqrt_diff_factor = np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor * exp_ratio_factor * sqrt_diff_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the square of the item size, the square root of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates additional adjustments based on the logarithm of the ratio between the current bin's capacity and the item size and the average remaining capacity of bins, promoting assignment to bins with lower capacities and closer to average remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n item_square = item ** 2\\n sqrt_ratio_factor = np.sqrt(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * item_square * sqrt_ratio_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates scores for each bin based on the ratio between the item size and the current bin's capacity, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * np.exp(-ratio) * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm calculates the scores for each bin based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the logarithm of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * ratio * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n # Add an additional factor that promotes assigning items to bins with higher remaining capacity\\n remaining_factor = (max_capacity - bins) / max_capacity\\n scores = scores * remaining_factor\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_35.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins that have more remaining capacity. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n log_ratio_factor = np.log10(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n sqrt_diff_factor = np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor * exp_ratio_factor * sqrt_diff_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the square of the item size, the square root of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates additional adjustments based on the logarithm of the ratio between the current bin's capacity and the item size and the average remaining capacity of bins, promoting assignment to bins with lower capacities and closer to average remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n item_square = item ** 2\\n sqrt_ratio_factor = np.sqrt(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * item_square * sqrt_ratio_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates scores for each bin based on the ratio between the item size and the current bin's capacity, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * np.exp(-ratio) * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm calculates the scores for each bin based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, and the index of the bin. It also incorporates an additional factor that adjusts the scores based on the logarithm of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nHere is the implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n scores = (item - bins) * ratio * diff_factor * index_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n # Add an additional factor that promotes assigning items to bins with higher remaining capacity\\n remaining_factor = (max_capacity - bins) / max_capacity\\n scores = scores * remaining_factor\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_36.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the sum of the exponents of the ratio and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the difference between the average remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_exp_log = np.sum(exp_ratio_factor + log_ratio_factor)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sum_exp_log * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins that have more remaining capacity. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n log_ratio_factor = np.log10(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n sqrt_diff_factor = np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor * exp_ratio_factor * sqrt_diff_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on factors such as the ratio between the bin's capacity and the item size, the difference between the maximum remaining capacity and the bin's capacity divided by the item size, and the manipulation of exponential and logarithmic functions.\\n\\nNew algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the product of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nThe code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = log_ratio_factor * np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * product_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the square of the item size, the square root of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates additional adjustments based on the logarithm of the ratio between the current bin's capacity and the item size and the average remaining capacity of bins, promoting assignment to bins with lower capacities and closer to average remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n item_square = item ** 2\\n sqrt_ratio_factor = np.sqrt(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * item_square * sqrt_ratio_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_37.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the sum of the exponents of the ratio and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the difference between the average remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_exp_log = np.sum(exp_ratio_factor + log_ratio_factor)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sum_exp_log * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on factors such as the ratio between the bin's capacity and the item size, the difference between the maximum remaining capacity and the bin's capacity divided by the item size, and the manipulation of exponential and logarithmic functions.\\n\\nNew algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the sum of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nThe code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins that have more remaining capacity. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n log_ratio_factor = np.log10(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n sqrt_diff_factor = np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor * exp_ratio_factor * sqrt_diff_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on factors such as the ratio between the bin's capacity and the item size, the difference between the maximum remaining capacity and the bin's capacity divided by the item size, and the manipulation of exponential and logarithmic functions.\\n\\nNew algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the product of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nThe code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = log_ratio_factor * np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * product_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_38.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the sum of the exponents of the ratio and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the difference between the average remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_exp_log = np.sum(exp_ratio_factor + log_ratio_factor)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sum_exp_log * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on factors such as the ratio between the bin's capacity and the item size, the difference between the maximum remaining capacity and the bin's capacity divided by the item size, and the manipulation of exponential and logarithmic functions.\\n\\nNew algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the sum of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nThe code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins that have more remaining capacity. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n log_ratio_factor = np.log10(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n sqrt_diff_factor = np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor * exp_ratio_factor * sqrt_diff_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_39.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the sum of the exponents of the ratio and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the difference between the average remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_exp_log = np.sum(exp_ratio_factor + log_ratio_factor)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sum_exp_log * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on factors such as the ratio between the bin's capacity and the item size, the difference between the maximum remaining capacity and the bin's capacity divided by the item size, and the manipulation of exponential and logarithmic functions.\\n\\nNew algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the sum of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nThe code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins that have more remaining capacity. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the maximum remaining capacity of all bins\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on a combination of factors\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n log_ratio_factor = np.log10(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n sqrt_diff_factor = np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor * exp_ratio_factor * sqrt_diff_factor\\n \\n # Amplify the scores based on a factor that promotes assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The algorithm accepts an item and a set of bins as input and returns the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot accommodate the item.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.max(bins) - bins, 0) - item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.1 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, named \\\"modified_score\\\", calculates the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot fully accommodate the item. It uses vectorized computations to improve performance.\",\n \"code\": \"import numpy as np\\n\\ndef modified_score(item, bins):\\n capacity_diffs = np.maximum(np.max(bins) - bins, 0)\\n scores = capacity_diffs - item\\n scores[scores < 0] += np.max(capacity_diffs) + 1\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - np.arange(len(bins)) + 0.5 * (max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins - item - np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_40.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\\text{score}}\\n\\n\\\\text{New algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the sum of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.}\\n\\n\\\\text{The main steps of the new algorithm are as follows:}\\n1. \\\\text{Calculate the maximum capacity of the bins.}\\n2. \\\\text{Calculate the ratio between the current bin's capacity and the item size for each bin.}\\n3. \\\\text{Calculate the difference between the maximum remaining capacity and the current bin's capacity divided by the item size for each bin.}\\n4. \\\\text{Calculate the index factor for each bin as the reciprocal of the base 10 logarithm of the bin's index.}\\n5. \\\\text{Calculate the exponential ratio factor for each bin as the exponential of the negative ratio between the bin's capacity and the item size.}\\n6. \\\\text{Calculate the logarithm ratio factor for each bin as the base 10 logarithm of the ratio between the bin's capacity and the item size.}\\n7. \\\\text{Calculate the sum factor for each bin as the sum of the logarithm ratio factor and the square root of the difference factor.}\\n8. \\\\text{Calculate the scores for each bin as the product of the factors calculated in steps 2-7, multiplied by the difference between the item size and the bin's capacity, the ratio, and the difference factor.}\\n9. \\\\text{Calculate the average ratio of the bins as the mean of the bin capacities divided by the item size.}\\n10. \\\\text{Calculate the penalty factor for each bin as a combination of factors that encourage assigning items to bins with closer to average remaining capacity.}\\n11. \\\\text{Calculate the final scores for each bin as the product of the scores calculated in step 8 and the penalty factor calculated in step 10.}\\n12. \\\\text{Return the final scores for the bins for assignment as a Numpy array.}\\n\\n\\\\begin{verbatim}\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n\\n return scores\\n\\\\end{verbatim\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to bins based on factors such as the ratio between the bin's capacity and the item size, the difference between the maximum remaining capacity and the bin's capacity divided by the item size, and the manipulation of exponential and logarithmic functions.\\n\\nNew algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, the exponent of the ratio between the current bin's capacity and the item size, and the sum of the exponents of the ratio and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, promoting assignment to bins that have more remaining capacity. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nThe code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n log_ratio_factor = np.log10(ratio)\\n exp_ratio_factor = np.exp(-ratio)\\n sum_exp_log = np.sum(exp_ratio_factor + log_ratio_factor)\\n sqrt_diff_factor = np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor * exp_ratio_factor * sum_exp_log * sqrt_diff_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio) ** 2 / avg_ratio ** 2)\\n scores = scores * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_41.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\\text{score}}\\n\\n\\\\text{New algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the sum of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.}\\n\\n\\\\text{The main steps of the new algorithm are as follows:}\\n1. \\\\text{Calculate the maximum capacity of the bins.}\\n2. \\\\text{Calculate the ratio between the current bin's capacity and the item size for each bin.}\\n3. \\\\text{Calculate the difference between the maximum remaining capacity and the current bin's capacity divided by the item size for each bin.}\\n4. \\\\text{Calculate the index factor for each bin as the reciprocal of the base 10 logarithm of the bin's index.}\\n5. \\\\text{Calculate the exponential ratio factor for each bin as the exponential of the negative ratio between the bin's capacity and the item size.}\\n6. \\\\text{Calculate the logarithm ratio factor for each bin as the base 10 logarithm of the ratio between the bin's capacity and the item size.}\\n7. \\\\text{Calculate the sum factor for each bin as the sum of the logarithm ratio factor and the square root of the difference factor.}\\n8. \\\\text{Calculate the scores for each bin as the product of the factors calculated in steps 2-7, multiplied by the difference between the item size and the bin's capacity, the ratio, and the difference factor.}\\n9. \\\\text{Calculate the average ratio of the bins as the mean of the bin capacities divided by the item size.}\\n10. \\\\text{Calculate the penalty factor for each bin as a combination of factors that encourage assigning items to bins with closer to average remaining capacity.}\\n11. \\\\text{Calculate the final scores for each bin as the product of the scores calculated in step 8 and the penalty factor calculated in step 10.}\\n12. \\\\text{Return the final scores for the bins for assignment as a Numpy array.}\\n\\n\\\\begin{verbatim}\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n\\n return scores\\n\\\\end{verbatim\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_42.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\\text{score}}\\n\\n\\\\text{New algorithm description: Assign scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and the sum of the logarithm of the ratio between the current bin's capacity and the item size and the square root of the difference between the maximum remaining capacity and the current bin's capacity divided by the item size. The scores will be amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.}\\n\\n\\\\text{The main steps of the new algorithm are as follows:}\\n1. \\\\text{Calculate the maximum capacity of the bins.}\\n2. \\\\text{Calculate the ratio between the current bin's capacity and the item size for each bin.}\\n3. \\\\text{Calculate the difference between the maximum remaining capacity and the current bin's capacity divided by the item size for each bin.}\\n4. \\\\text{Calculate the index factor for each bin as the reciprocal of the base 10 logarithm of the bin's index.}\\n5. \\\\text{Calculate the exponential ratio factor for each bin as the exponential of the negative ratio between the bin's capacity and the item size.}\\n6. \\\\text{Calculate the logarithm ratio factor for each bin as the base 10 logarithm of the ratio between the bin's capacity and the item size.}\\n7. \\\\text{Calculate the sum factor for each bin as the sum of the logarithm ratio factor and the square root of the difference factor.}\\n8. \\\\text{Calculate the scores for each bin as the product of the factors calculated in steps 2-7, multiplied by the difference between the item size and the bin's capacity, the ratio, and the difference factor.}\\n9. \\\\text{Calculate the average ratio of the bins as the mean of the bin capacities divided by the item size.}\\n10. \\\\text{Calculate the penalty factor for each bin as a combination of factors that encourage assigning items to bins with closer to average remaining capacity.}\\n11. \\\\text{Calculate the final scores for each bin as the product of the scores calculated in step 8 and the penalty factor calculated in step 10.}\\n12. \\\\text{Return the final scores for the bins for assignment as a Numpy array.}\\n\\n\\\\begin{verbatim}\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n\\n return scores\\n\\\\end{verbatim\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n sum_factor = log_ratio_factor + np.sqrt(diff_factor)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * sum_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_43.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size. It also incorporates an additional factor that adjusts the scores based on the exponential of the ratio between the current bin's capacity and the item size, promoting assignment to bins with lower capacities. Finally, the scores are amplified based on a factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = scores * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_44.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_45.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_46.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_47.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_48.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_49.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio))\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The algorithm accepts an item and a set of bins as input and returns the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot accommodate the item.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.max(bins) - bins, 0) - item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.1 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, named \\\"modified_score\\\", calculates the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot fully accommodate the item. It uses vectorized computations to improve performance.\",\n \"code\": \"import numpy as np\\n\\ndef modified_score(item, bins):\\n capacity_diffs = np.maximum(np.max(bins) - bins, 0)\\n scores = capacity_diffs - item\\n scores[scores < 0] += np.max(capacity_diffs) + 1\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - np.arange(len(bins)) + 0.5 * (max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor that increases as the remaining capacity approaches zero. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are further from being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n capacity_diffs = max_capacity - bins\\n scores = capacity_diffs - item - np.arange(len(bins)) + (max_capacity - bins) * 0.1\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_50.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_51.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_52.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_53.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n log_ratio_factor = np.log10(ratio)\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * log_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the square root of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n sqrt_ratio_factor = np.sqrt(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * sqrt_ratio_factor * penalty_factor\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_54.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while adding a new factor which is the square of the ratio between the current bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n square_ratio_factor = ratio ** 2\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor * square_ratio_factor\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_55.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while adding a new factor which is the square of the ratio between the current bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n square_ratio_factor = ratio ** 2\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor * square_ratio_factor\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_56.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_57.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_58.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_59.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The algorithm accepts an item and a set of bins as input and returns the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot accommodate the item.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.max(bins) - bins, 0) - item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.1 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, named \\\"modified_score\\\", calculates the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot fully accommodate the item. It uses vectorized computations to improve performance.\",\n \"code\": \"import numpy as np\\n\\ndef modified_score(item, bins):\\n capacity_diffs = np.maximum(np.max(bins) - bins, 0)\\n scores = capacity_diffs - item\\n scores[scores < 0] += np.max(capacity_diffs) + 1\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - np.arange(len(bins)) + 0.5 * (max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor that increases as the remaining capacity approaches zero. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n capacity_diffs = max_capacity - bins\\n scores = capacity_diffs - item + np.arange(len(bins)) + (max_capacity - bins) * 0.1\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_60.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log10(np.arange(1, len(bins)+1))\\n exp_ratio_factor = np.exp(-ratio)\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_ratio_factor * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_61.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_62.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_63.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nMy new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the logarithm of the ratio between the current bin's capacity and the item size, and the exponential of the ratio between the current bin's capacity and the item size, all while incorporating a penalty factor that encourages assigning items to bins with closer to average remaining capacity and a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n ratio = bins / item\\n avg_ratio = np.mean(bins) / item\\n \\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins)+1)) * np.exp(-ratio) * np.log10(ratio) * (1 + (1 - np.abs(ratio)) + (np.abs(ratio - avg_ratio)**2 / avg_ratio**2))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_64.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * diff_factor\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * diff_factor * ratio * index_factor * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_65.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * diff_factor\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * diff_factor * ratio * index_factor * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_66.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * diff_factor\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * diff_factor * ratio * index_factor * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_67.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * diff_factor\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * diff_factor * ratio * index_factor * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_68.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * diff_factor\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * diff_factor * ratio * index_factor * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_69.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'The new algorithm assigns scores to bins based on the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the natural logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = 1 / np.log(np.arange(1, len(bins)+1))\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n scores = (item - bins) * ratio * diff_factor * index_factor * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"new_algorithm: The algorithm accepts an item and a set of bins as input and returns the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot accommodate the item.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(np.max(bins) - bins, 0) - item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.1 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, named \\\"modified_score\\\", calculates the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot fully accommodate the item. It uses vectorized computations to improve performance.\",\n \"code\": \"import numpy as np\\n\\ndef modified_score(item, bins):\\n capacity_diffs = np.maximum(np.max(bins) - bins, 0)\\n scores = capacity_diffs - item\\n scores[scores < 0] += np.max(capacity_diffs) + 1\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - np.arange(len(bins)) + 0.5 * (max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, named \\\"modified_score\\\", calculates the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot fully accommodate the item. It uses vectorized computations to improve performance.\",\n \"code\": \"import numpy as np\\n\\ndef modified_score(item, bins):\\n capacity_diffs = np.maximum(np.max(bins) - bins, 0)\\n scores = capacity_diffs - item\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_70.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_71.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_72.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_73.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, the logarithm of the ratio factor, and an additional factor that calculates the product of the ratio and the difference factor.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n product_factor = ratio * diff_factor\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor * product_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_74.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin cubed, the logarithm of the ratio factor, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\nPython implementation of the new algorithm:\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_75.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin cubed, the logarithm of the ratio factor, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\nPython implementation of the new algorithm:\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_76.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin cubed, the logarithm of the ratio factor, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\nPython implementation of the new algorithm:\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_77.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin cubed, the logarithm of the ratio factor, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\nPython implementation of the new algorithm:\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_78.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin squared, the exponential of the difference factor, and the logarithm of the ratio factor. The scores will be amplified based on a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.square(1 / np.log10(np.arange(1, len(bins)+1)))\\n exp_diff_factor = np.exp(diff_factor)\\n log_ratio_factor = np.log10(ratio)\\n scores = (item - bins) * ratio * diff_factor * index_factor * exp_diff_factor * log_ratio_factor\\n\\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin cubed, the logarithm of the ratio factor, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\nPython implementation of the new algorithm:\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_79.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average multiplied by the square root of the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor * np.sqrt(np.log10(ratio))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin cubed, the logarithm of the ratio factor, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\nPython implementation of the new algorithm:\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item + 0.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.1 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item - np.arange(len(bins)) + 1.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm, named \\\"modified_score\\\", calculates the scores for the bins based on their rest capacities and the item size, considering a penalty factor for bins that cannot fully accommodate the item. It uses vectorized computations to improve performance.\",\n \"code\": \"import numpy as np\\n\\ndef modified_score(item, bins):\\n capacity_diffs = np.maximum(np.max(bins) - bins, 0)\\n scores = capacity_diffs - item\\n scores[scores < 0] += np.max(capacity_diffs) + 1\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - np.arange(len(bins)) + 0.5 * (max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_80.json", "content": "[\n {\n \"algorithm\": \"I propose a new algorithm that assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the inverse of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-1 / ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on factors such as the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, and the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nNew algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average. \\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin, the exponential of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average multiplied by the square root of the logarithm of the ratio between the current bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n penalty_factor = 2 - ratio\\n scores = (item - bins) * ratio * (max_capacity - bins) / item * 1 / np.log10(np.arange(1, len(bins) + 1)) * np.exp(-ratio) * penalty_factor * np.sqrt(np.log10(ratio))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on a combination of factors, including the ratio between the current bin's capacity and the item size, the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the index of the bin cubed, the logarithm of the ratio factor, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average.\\nPython implementation of the new algorithm:\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n diff_factor = (max_capacity - bins) / item\\n index_factor = np.power(1 / np.log10(np.arange(1, len(bins)+1)), 3)\\n log_ratio_factor = np.log10(ratio)\\n \\n scores = (item - bins) * ratio * diff_factor * index_factor * log_ratio_factor\\n \\n avg_ratio = np.mean(bins) / item\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(avg_ratio - (bins / item)) / item**2)\\n scores = scores * penalty_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the difference between the maximum remaining capacity and the current bin's capacity divided by the item size, the ratio between the current bin's capacity and the item size, the index of the bin squared, the logarithm of the ratio between the current bin's capacity and the item size, and a penalty factor that encourages assigning items to bins with closer to average remaining capacity, with a stronger emphasis on bins that have a remaining capacity closer to the average, while also incorporating an additional factor that calculates the product of the ratio and the difference factor, and an exponential factor of the ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n log_ratio_factor = np.log10(ratio)\\n penalty_factor = 1 + (1 - np.abs(ratio)) + (np.abs(np.mean(bins) / item - ratio) / item)\\n product_factor = ratio * ((max_capacity - bins) / item)\\n exp_ratio_factor = np.exp(-ratio)\\n scores = (item - bins) * ((max_capacity - bins) / item) * ratio * np.square(1 / np.log10(np.arange(1, len(bins)+1))) * log_ratio_factor * penalty_factor * product_factor * exp_ratio_factor\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_PopSize/5run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item. It also considers an additional factor based on the index of the bin to prioritize assigning items to bins with lower indices before higher indices.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - 0.1 * np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (-bins) - item - np.arange(len(bins)) + 1.5 * (-bins)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and a penalty factor for bins that cannot accommodate the item, while also considering an additional factor based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins by calculating a score for each bin based on its remaining capacity, the item size, and an additional factor that penalizes bins with small remaining capacity. The algorithm then adjusts the scores based on the index of the bin to prioritize assigning items to bins with higher indices before lower indices. Finally, the algorithm incorporates a factor that amplifies the scores based on the difference between the maximum remaining capacity and the current bin's capacity, adding more weight to bins that are closer to being full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - item - np.arange(len(bins)) + 0.5 * (max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function assigns items to bins based on the maximum score, while avoiding using bins at maximum capacity in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == np.max(bins)] = -1\\n scores = remaining_capacity / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with more remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, bins - item) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will assign a score to each bin based on the remaining capacity after placing the item. The score will be calculated by taking the reciprocal of the difference between the bin capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity. Higher scores indicate better candidates for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.15595,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm calculates the score for each bin based on the rest capacity and assigns the item to the bin with the maximum score, aiming to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = np.maximum(0, max_capacity - bins) # Calculate rest capacity\\n mask = rest_capacity < item # Check if rest capacity is enough for the item\\n rest_capacity[mask] = 0 # Set rest capacity to 0 if it's not enough\\n scores = rest_capacity / (max_capacity * (1 - mask)) # Calculate scores for each bin\\n return scores\",\n \"objective\": 0.31975,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the score for each bin by taking the ratio of the rest capacity to the item size, and then subtracting 1 if the rest capacity equals the maximum capacity, in order to prioritize the bin with the largest available space but not the maximum capacity, with the main steps being to calculate the scores and return them as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm as follows:\\nThe algorithm will calculate the score for each bin based on the remaining capacity after assigning the item, with a penalty for bins at maximum capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) - (bins == bins.max()) * (item + 1)\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the remaining capacity of each bin after assigning the item, and then assigns a score to each bin based on the ratio of remaining capacity to the maximum capacity, with a penalty for bins with maximum capacity. It then returns the scores for all bins using Numpy array. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_ratio = remaining_capacity / np.max(bins)\\n remaining_ratio[bins == np.max(bins)] -= 0.5 # Apply penalty for bins with maximum capacity\\n scores = remaining_ratio\\n return scores\",\n \"objective\": 0.40739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves ranking the bins based on their remaining capacity after assigning the item, and penalizing bins with maximum capacity to discourage their use. First, calculate the remaining capacity of each bin after assigning the item, then calculate the score for each bin by considering its remaining capacity and penalizing bins with maximum capacity. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalized_capacity = np.where(remaining_capacity < np.max(remaining_capacity), remaining_capacity, np.max(remaining_capacity) * 2)\\n scores = penalized_capacity * (1 + np.log(1 + np.abs(penalized_capacity - np.max(penalized_capacity))))\\n return scores\",\n \"objective\": 0.5735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the minimum between the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.maximum(bins - item, 0)\\n scores = np.minimum(capacities, item)\\n return scores\",\n \"objective\": 0.64021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: First, calculate the free space in each bin after adding the item, then compute the score for each bin using a novel formula that takes into account the free space and the distance from the maximum capacity, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_space = bins - item\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - remaining_space\\n scores = remaining_space * (1 + distance_from_max)\\n return scores\",\n \"objective\": 0.77412,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the following formula: score = (bin_capacity - item_size) * (1 - bin_index/N), where N is the total number of bins. Then, the function will return the scores for each bin in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n scores = (bins - item) * (1 - np.arange(N)/N)\\n return scores\",\n \"objective\": 0.89174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacity of each bin after adding the item, and then scores each bin based on the formula: ((maximum capacity - available capacity) / maximum capacity) * available capacity, where bins with the maximum capacity are not scored. Finally, the function returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n available_capacity = np.maximum(0, (bins + item) - max_capacity)\\n scores = ((max_capacity - available_capacity) / max_capacity) * available_capacity\\n scores[available_capacity == 0] = 0\\n return scores\",\n \"objective\": 1.21401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplementing the algorithm:\\n1. Create a function named score that accepts two input parameters: 'item' and 'bins'.\\n2. Inside the function, calculate the scores for each bin by first finding the difference between the maximum capacity of each bin and the size of the item.\\n3. For bins that have a rest capacity equal to the maximum capacity, assign a score of -1 to make them ineligible for item assignment.\\n4. Return the calculated scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == bins.max()).astype(int) * -1\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm: The algorithm first calculates the scores for each bin based on the rest capacity and the current item size, then it returns the scores for the bins for assignment.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0)\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the ratio between the remaining capacity and the item size, with a penalty factor for bins at maximum capacity, and incorporates a custom function to further promote accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n # custom function: e^(-|x|^2)\\n custom_score = np.exp(-np.abs(ratio)**2)\\n scores[i] = custom_score * (1 + penalty_factor * (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the inverse of the difference between the bin's remaining capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity, and also considering the proximity of the bin to the item size, promoting more accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, with a penalty factor for bins at maximum capacity, and incorporates a quadratic function to further promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = ((remaining_capacity - item)**2) / (item**2)\\n else:\\n scores[i] = ((remaining_capacity - item)**2) / (item**2) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, with a penalty factor for bins at maximum capacity, and incorporates a quadratic function to further promote accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = (remaining_capacity - item + 1) ** 2 / (item + 1) ** 2\\n else:\\n scores[i] = ((remaining_capacity - item + 1) ** 2 / (item + 1) ** 2) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on a combination of the remaining capacity and the proximity to the item size, with a penalty factor for bins at maximum capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / item)\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity and a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, and a penalty factor for bins at maximum capacity, to further optimize the assignment process.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / max_capacity)\\n ratio_factor = np.exp(-bins / item) / (1 + np.exp(-bins / item))\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and the penalty factor for bins at maximum capacity, with a different parameter setting.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / item)\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * np.exp(penalty_factor)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, with a penalty factor for bins at maximum capacity, and incorporates a logarithmic function to further promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = np.log(remaining_capacity - item + 1) / np.log(item + 1)\\n else:\\n scores[i] = (np.log(remaining_capacity - item + 1) / np.log(item + 1)) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and the ratio of their remaining capacity to the size of the item, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.exp(-ratios) / (1 + np.exp(-ratios))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the proximity of the bin's remaining capacity to the item size, with a penalty factor for bins at maximum capacity, and incorporates a logarithmic function to further promote accurate assignments. \\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = np.log(remaining_capacity - item + 1)\\n else:\\n scores[i] = np.log(remaining_capacity - item) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity and a penalty factor for bins at maximum capacity, with a weight factor for the remaining capacity that decreases exponentially as the capacity approaches the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-bins / (item + 1))\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the ratio of the remaining capacity to the item size, and a penalty factor for bins at maximum capacity, using mathematical functions to optimize the assignment process.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-np.abs((bins - item) / max_capacity)**3)\\n ratio_factor = np.sqrt(np.exp(-bins / item) / (1 + np.exp(-bins / item)))**2\\n penalty_factor = np.exp(-np.abs((max_capacity - bins) / item)**4)\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on a combination of the remaining capacity and the proximity to the item size, with a penalty factor for bins at maximum capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / max_capacity)\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity and a penalty factor for bins at maximum capacity, with a weight factor for the remaining capacity that decreases as the capacity approaches the item size.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - bins / (item + 1))\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the sum of the inverse of the difference between the bin's remaining capacity and the item size, and the inverse of the bin's remaining capacity, with a penalty factor for bins at maximum capacity, and incorporates a logarithmic function to further promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1) + 1 / (remaining_capacity + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor + 1 / (remaining_capacity + 1)\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n scores[i] += np.log(remaining_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_bins = bins / max_capacity\\n normalized_item = item / max_capacity\\n scores = (1 - normalized_bins) + (normalized_bins == 1) * normalized_item\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins, dtype=float)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, a penalty factor for bins with remaining capacity less than half of the item size, and a weight factor based on the index squared and multiplied by two. The scores are returned as a Numpy array.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratio_capacity = remaining_capacity / item\\n penalty_factor = (remaining_capacity < item/2).astype(int)\\n index_factor = (np.arange(len(bins)) ** 2) * 2\\n scores = ratio_capacity + penalty_factor - index_factor\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity and the ratio of remaining capacity to the sum of the remaining capacity and the item size, with a penalty factor for bins at maximum capacity plus a weight factor based on their index, and then returns the scores as a Numpy array.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratio_capacity = remaining_capacity / (remaining_capacity + item)\\n penalty_factor = bins == max_capacity\\n index_factor = np.arange(len(bins)) ** 2\\n scores = ratio_capacity + penalty_factor - index_factor\\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity + item) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher sum values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n sum_scores = (remaining_capacity % item) * np.log(remaining_capacity) + np.sqrt(item / remaining_capacity) + np.exp(item * remaining_capacity)\\n \\n scores = sum_scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n remaining_capacity_normalized = remaining_capacity / max_capacity\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity_normalized)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the inverse of the bin's remaining capacity divided by the item size, multiplied by a penalty factor if the bin is already at maximum capacity, and also considering the proximity of the bin to the item size, promoting more accurate assignments. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = (1 / remaining_capacity) / item\\n else:\\n scores[i] = ((1 / remaining_capacity) / item) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the proximity of the bin's remaining capacity to the item size and incorporates a penalty factor for bins at maximum capacity, while promoting accurate assignments by using a sigmoid function.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n sigmoid_score = 1 / (1 + np.exp(-remaining_capacity + item))\\n scores[i] = sigmoid_score * np.log(remaining_capacity - item + 1) - np.abs((bin_capacity - item) / max_capacity) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on calculating the scores for each bin by considering the ratio between the remaining capacity and the item size, along with a penalty factor for bins at maximum capacity. Additionally, a custom function is incorporated to further optimize the assignment accuracy. The modified version of the algorithm is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n # custom function: e^(-|x|^2)\\n custom_score = np.exp(-np.abs(ratio)**2)\\n scores[i] = custom_score * (1 + penalty_factor * (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the inverse of the difference between the bin's remaining capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity, and also considering the proximity of the bin to the item size, promoting more accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a weighted combination of the remaining capacity, the ratio between the remaining capacity and the item size, and a penalty factor for bins at maximum capacity, using a customized function to further optimize the assignment accuracy.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n custom_score = np.exp(-(ratio**2)) * np.log(remaining_capacity / item + 1)\\n scores[i] = custom_score - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign items to bins with the maximum score, considering the ratio between the remaining capacity and the item size, along with a penalty factor for bins at maximum capacity. The custom function is modified to incorporate a quadratic term, resulting in a more precise optimization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n \\n # custom function: e^(-k|x|^2)\\n k = 0.5\\n custom_score = np.exp(-k*np.abs(ratio)**2)\\n \\n scores[i] = custom_score * (1 + penalty_factor * (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, with a penalty factor for bins at maximum capacity, and incorporates a quadratic function to further promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = ((remaining_capacity - item)**2) / (item**2)\\n else:\\n scores[i] = ((remaining_capacity - item)**2) / (item**2) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, with a penalty factor for bins at maximum capacity, and incorporates a quadratic function to further promote accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = ((remaining_capacity - item + 1) / (item + 1)) ** 2\\n else:\\n scores[i] = ((remaining_capacity - item + 1) / (item + 1)) ** 2 * 1000\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, a penalty factor for bins at maximum capacity, and a custom function that involves the logarithmic transformation of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-np.abs((bins - item) / item)**2)\\n ratio_factor = np.cos((bins - item) / item) / (1 + np.sin((bins - item) / item))\\n penalty_factor = bins == max_capacity\\n custom_factor = np.log(1 + bins / max_capacity)\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor) * custom_factor\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, and a penalty factor for bins at maximum capacity, while also considering the logarithm of the remaining capacity to promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / max_capacity)\\n ratio_factor = np.exp(-bins / item) / (1 + np.exp(-bins / item))\\n penalty_factor = bins == max_capacity\\n log_capacity = np.log(np.maximum(1, bins))\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor) * log_capacity\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on a combination of the remaining capacity and the proximity to the item size, with a penalty factor for bins at maximum capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / item)\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the inverse of the remaining capacity multiplied by the logarithm of the item size, with a penalty factor for bins at maximum capacity, to ensure accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(1, bins - item)\\n ratio_factor = 1 / remaining_capacity * np.log(item)\\n penalty_factor = bins == max_capacity\\n scores = ratio_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, and a penalty factor for bins at maximum capacity. It also incorporates a custom function that utilizes the sine and cosine of the remaining capacity to further optimize the assignment accuracy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-np.abs((bins - item) / item)**2)\\n ratio_factor = np.cos((bins - item) / item) / (1 + np.sin((bins - item) / item))\\n penalty_factor = bins == max_capacity\\n custom_factor = np.sin(np.pi * (bins / max_capacity))\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor) * custom_factor\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the difference between the bin capacity and the item size, and the penalty factor for bins at maximum capacity.\",\n \"code\": \"def score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n proximity_factor = np.maximum(0, 1 - (remaining_capacity / max_capacity))\\n difference_factor = max_capacity - remaining_capacity\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * (1 + difference_factor) * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and the penalty factor for bins at maximum capacity, with a different parameter setting.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / item)\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * np.exp(penalty_factor)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and the penalty factor for bins at maximum capacity, using a combination of mathematical functions and matrix operations to optimize the assignment process.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-np.abs((bins - item) / item)**2)\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * np.sqrt(np.exp(penalty_factor))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and the ratio of their remaining capacity to the size of the item, and returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.exp(-ratios) / (1 + np.exp(-ratios))\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the combination of the logarithm of the remaining capacity, the proximity to the item size raised to a power, and a penalty factor for bins at maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / item)\\n penalty_factor = bins == max_capacity\\n log_capacity = np.log(np.maximum(1, bins))\\n scores = log_capacity * np.power(proximity_factor, 3) * np.exp(penalty_factor)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the difference between the remaining capacity of the bin and the item size, with a penalty factor for bins at maximum capacity, and incorporates a quadratic function to further promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = (remaining_capacity - item)**2\\n else:\\n scores[i] = (remaining_capacity - item)**2 * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of logarithmic and exponential functions applied to the remaining capacity and penalty factor for bins at maximum capacity, with a custom function incorporated to further optimize the assignment accuracy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n exp_factor = np.exp(-np.abs(np.log(remaining_capacity) / np.log(item+1))**2)\\n scores[i] = exp_factor * (1 + (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the harmonic mean of the item size and the remaining capacity, the square root of the logarithm of the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n harmonic_mean = 2 / (1/item + 1/remaining_capacity)\\n sqrt_log_capacity = np.sqrt(np.log(remaining_capacity))\\n \\n scores = harmonic_mean * sqrt_log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the factor of the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm description (within braces): \\nThe new algorithm will calculate the scores for each bin based on the inverse of the bin's remaining capacity divided by the item size, multiplied by a penalty factor if the bin is already at maximum capacity, and also considering the square of the proximity of the bin to the item size, promoting more accurate assignments. \\n\\nImplemented new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = (1 / remaining_capacity) / item\\n else:\\n scores[i] = ((1 / remaining_capacity) / item) * penalty_factor\\n \\n scores[i] -= np.square((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the inverse of the bin's remaining capacity divided by the item size, multiplied by a penalty factor if the bin is already at maximum capacity, and also considering the proximity of the bin to the item size, promoting more accurate assignments. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = (1 / remaining_capacity) / item\\n else:\\n scores[i] = ((1 / remaining_capacity) / item) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the proximity of the bin's remaining capacity to the item size and incorporates a penalty factor for bins at maximum capacity, while promoting accurate assignments by using a sigmoid function.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n sigmoid_score = 1 / (1 + np.exp(-remaining_capacity + item))\\n scores[i] = sigmoid_score * np.log(remaining_capacity - item + 1) - np.abs((bin_capacity - item) / max_capacity) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.01851,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin by considering the ratio between the remaining capacity and the item size, along with a penalty factor for bins at maximum capacity. It also incorporates a logarithmic function to penalize larger ratios more heavily and a square function to reward smaller ratios.\\n\\nNew algorithm implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n # custom function: ln(1 + e^(-x^2))\\n custom_score = np.log(1 + np.exp(-np.square(ratio)))\\n scores[i] = custom_score * (1 + penalty_factor * (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the ratio between the remaining capacity and the item size, and a penalty factor for bins at maximum capacity, using a combination of mathematical functions to optimize the assignment accuracy.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n \\n # Custom function: ((e^(-k1 |x|)) / (e^(k2 x^2))) * (1 + penalty_factor * (bins[i] == max_capacity))\\n k1 = 0.5\\n k2 = 1\\n custom_score = (np.exp(-k1*np.abs(ratio)) / np.exp(k2*ratio**2)) * (1 + (bins[i] == max_capacity))\\n \\n scores[i] = custom_score - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the ratio between the remaining capacity and the item size, and a penalty factor for bins at maximum capacity, using a combination of mathematical functions to optimize the assignment accuracy with different parameter settings for k1 and k2.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n \\n # Custom function: ((e^(-k1 |x|)) / (e^(k2 x^2))) * (1 + penalty_factor * (bins[i] == max_capacity))\\n k1 = 1.0 # change k1 parameter value\\n k2 = 0.5 # change k2 parameter value\\n custom_score = (np.exp(-k1*np.abs(ratio)) / np.exp(k2*ratio**2)) * (1 + (bins[i] == max_capacity))\\n \\n scores[i] = custom_score - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02656,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the item size, and a penalty factor for bins at maximum capacity. It also incorporates a non-linear function to further promote accurate assignments.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n \\n # Custom non-linear function: (cos(x))^2 / (1 + |x|^3)\\n custom_score = (np.cos(ratio)**2) / (1 + np.abs(ratio)**3)\\n \\n scores[i] = custom_score * (1 + penalty_factor * (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign items to bins by calculating scores that take into account the remaining capacity of each bin, along with a penalty factor for bins at maximum capacity. The algorithm will prioritize bins with higher remaining capacity and lower penalty. The main steps of the algorithm are as follows:\\n\\n1. Initialize the necessary variables, including the maximum capacity of all bins, the penalty factor, and an array to store the scores for each bin.\\n\\n2. Iterate through each bin and calculate the score based on the ratio between the remaining capacity and the item size. Exclude bins with maximum capacity from consideration.\\n\\n3. Apply a custom function to further optimize the assignment accuracy. The custom function is defined as the exponential of the negative square of the ratio.\\n\\n4. Adjust the scores based on the penalty factor for bins at maximum capacity. Multiply the custom score by (1 + penalty_factor) if the bin capacity equals the maximum capacity.\\n\\n5. Subtract a term from the scores that represents the difference between the bin capacity and the item size normalized by the maximum capacity. This term penalizes bins with smaller capacity.\\n\\n6. Return the array of scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n # custom function\\n custom_score = np.exp(-np.abs(ratio)**2)\\n scores[i] = custom_score * (1 + penalty_factor * (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the inverse of the difference between the bin's remaining capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity, and also considering the proximity of the bin to the item size, promoting more accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of mathematical functions that consider the remaining capacity, the ratio between the remaining capacity and the item size, and a penalty factor for bins at maximum capacity. The algorithm will also incorporate a logarithmic function and a power function to further optimize the assignment accuracy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n \\n # Custom function: ((ln(1 + e^(-k1 |x|^2))) / ((e^(k2 x))^(1/k3))) * (1 + penalty_factor * (bins[i] == max_capacity))\\n k1 = 0.5\\n k2 = 1\\n k3 = 2\\n custom_score = ((np.log(1 + np.exp(-k1*np.abs(ratio)**2))) / ((np.exp(k2*ratio))**(1/k3))) * (1 + (bins[i] == max_capacity))\\n \\n scores[i] = custom_score - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a weighted combination of the remaining capacity, the ratio between the remaining capacity and the item size, and a penalty factor for bins at maximum capacity, using a customized function to further optimize the assignment accuracy.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n custom_score = np.exp(-(ratio**2)) * np.log(remaining_capacity / item + 1)\\n scores[i] = custom_score - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the remaining capacity raised to the power of the item size, divided by the square root of the remaining capacity, with a penalty factor for bins at maximum capacity, to optimize the assignment accuracy.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n penalty_factor = bins == max_capacity\\n scores = np.power(remaining_capacity, item) / np.sqrt(remaining_capacity) * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.03662,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign items to bins with the maximum score, considering the ratio between the remaining capacity and the item size, along with a penalty factor for bins at maximum capacity. The custom function is modified to incorporate a quadratic term, resulting in a more precise optimization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n ratio = remaining_capacity / item\\n \\n # custom function: e^(-k|x|^2)\\n k = 0.5\\n custom_score = np.exp(-k*np.abs(ratio)**2)\\n \\n scores[i] = custom_score * (1 + penalty_factor * (bins[i] == max_capacity)) - np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms all calculate scores for assigning items to bins based on the remaining capacity of the bins and the item size, with penalty factors for bins at maximum capacity.\\n\\nNew algorithm description (within braces): The new algorithm calculates scores for each bin by considering the remaining capacity raised to the power of the item size divided by the square root of the remaining capacity, with an additional term that incorporates the square of the difference between the bin capacity and the item size.\\n\\nImplemented new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = np.power(remaining_capacity, item) / np.sqrt(remaining_capacity)\\n scores -= np.square(bins - item)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, with a penalty factor for bins at maximum capacity, and incorporates a quadratic function to further promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = ((remaining_capacity - item)**2) / (item**2)\\n else:\\n scores[i] = ((remaining_capacity - item)**2) / (item**2) * penalty_factor\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, with a penalty factor for bins at maximum capacity, and incorporates a quadratic function to further promote accurate assignments.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i, bin_capacity in enumerate(bins):\\n if bin_capacity == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bin_capacity\\n if remaining_capacity >= item:\\n scores[i] = ((remaining_capacity - item + 1) / (item + 1)) ** 2\\n else:\\n scores[i] = ((remaining_capacity - item + 1) / (item + 1)) ** 2 * 1000\\n \\n scores[i] -= np.abs((bin_capacity - item) / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, a penalty factor for bins at maximum capacity, and a custom function that involves the logarithmic transformation of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-np.abs((bins - item) / item)**2)\\n ratio_factor = np.cos((bins - item) / item) / (1 + np.sin((bins - item) / item))\\n penalty_factor = bins == max_capacity\\n custom_factor = np.log(1 + bins / max_capacity)\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor) * custom_factor\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, a penalty factor for bins at maximum capacity, and a custom function that involves the square root transformation of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-np.abs((bins - item) / item)**2)\\n ratio_factor = np.cos((bins - item) / item) / (1 + np.sin((bins - item) / item))\\n penalty_factor = bins == max_capacity\\n custom_factor = np.sqrt(bins)\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor) * custom_factor\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores based on the remaining capacity of bins and assigning the item to the bin with the maximum score in each step to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, and a penalty factor for bins at maximum capacity, while also considering the logarithm of the remaining capacity to promote accurate assignments.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.maximum(0, 1 - (bins - item) / max_capacity)\\n ratio_factor = np.exp(-bins / item) / (1 + np.exp(-bins / item))\\n penalty_factor = bins == max_capacity\\n log_capacity = np.log(np.maximum(1, bins))\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor) * log_capacity\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on a combination of the proximity to the item size, the ratio of the remaining capacity to the item size, and a penalty factor for bins at maximum capacity, to optimize the assignment accuracy.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity_factor = np.exp(-np.abs((bins - item) / item)**2)\\n ratio_factor = np.cos((bins - item) / item) / (1 + np.sin((bins - item) / item))\\n penalty_factor = bins == max_capacity\\n scores = proximity_factor * ratio_factor * (1 + penalty_factor)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item) / (np.log(item) * (bins - item))**0.7 - 0.5*(bins == np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the remaining capacity, the logarithm of the remaining capacity, and a sine function of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity, lower square root values, higher logarithmic values, and lower sine values have higher scores. The scores are further adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_values = np.sqrt(remaining_capacity)\\n log_values = np.log(remaining_capacity)\\n sine_values = np.sin(item / remaining_capacity)\\n scores = remaining_capacity + sqrt_values + log_values + sine_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the cube root of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, lower cube root values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n cube_root = np.cbrt(remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + cube_root\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = 1 / (item / remaining_capacity)\\n sqrt_values = 1 / np.sqrt(remaining_capacity)\\n scores = remaining_capacity + ratios + sqrt_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, and penalizes bins with maximum capacity. The scores are then scaled by the logarithm of the bin's remaining capacity and the exponential of the negative ratio. Finally, the scores are adjusted based on the maximum capacity of the bins and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe common backbone idea in the provided algorithms is to assign scores to each bin based on the remaining capacity and the ratio between the item size and the remaining capacity, while considering the maximum capacity of the bins and penalizing bins at maximum capacity.\\n\\nMy new algorithm assigns scores to each bin based on the sum of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the cube root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher cube root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = remaining_capacity + np.log(ratios) + np.cbrt(remaining_capacity)\\n scores = scores / np.mean(bins) # Replaced 'max_capacity' with 'np.mean(bins)'\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (item * remaining_capacity)\\n scores = remaining_capacity + ratios\\n scores = scores / np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates scores for each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, the maximum capacity of the bins, and the number of already assigned items to each bin, ensuring that bins with higher remaining capacity, lower ratios, lower number of assigned items, and higher maximum capacity have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 - num_assigned_items / len(bins))\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, raised to the power of 0.5, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 0.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, raised to the power of 2.5, ensuring that bins with higher remaining capacity, lower ratios, and lower maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (np.sqrt(remaining_capacity) * np.log(ratios) ** 2.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square of the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity) ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the remaining capacity, the logarithm of the remaining capacity, and a sine function of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity, lower square root values, higher logarithmic values, and lower sine values have higher scores. The scores are further adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_values = np.sqrt(remaining_capacity)\\n log_values = np.log(remaining_capacity)\\n sine_values = np.sin(item / remaining_capacity)\\n scores = remaining_capacity + sqrt_values + log_values + sine_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the cube root of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, lower cube root values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n cube_root = np.cbrt(remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + cube_root\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, and the exponential of the square root of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, and lower square root ratios. The scores are then normalized based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios)\\n scores = remaining_capacity + log_capacity*exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = 1 / (item / remaining_capacity)\\n sqrt_values = 1 / np.sqrt(remaining_capacity)\\n scores = remaining_capacity + ratios + sqrt_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, and penalizes bins with maximum capacity. The scores are then scaled by the logarithm of the bin's remaining capacity and the exponential of the negative ratio. Finally, the scores are adjusted based on the maximum capacity of the bins and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (item * remaining_capacity)\\n scores = remaining_capacity + ratios\\n scores = scores / np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the mean capacity of the bins, ensuring that bins with higher remaining capacity, lower logarithmic ratios, and higher mean capacity have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n mean_capacity = np.mean(bins)\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (mean_capacity / max_capacity)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size to the remaining capacity, and the square of the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the remaining capacity, the logarithm of the remaining capacity, and a sine function of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity, lower square root values, higher logarithmic values, and lower sine values have higher scores. The scores are further adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_values = np.sqrt(remaining_capacity)\\n log_values = np.log(remaining_capacity)\\n sine_values = np.sin(item / remaining_capacity)\\n scores = remaining_capacity + sqrt_values + log_values + sine_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the cube root of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, lower cube root values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n cube_root = np.cbrt(remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + cube_root\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the item size to the remaining capacity, and the cube of the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher inverse values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n inverse_capacity = 1 / remaining_capacity\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + inverse_capacity\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size to the remaining capacity, and the square of the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher inverse values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n inverse_capacity = 1 / remaining_capacity\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + inverse_capacity\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = item / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the item size divided by the remaining capacity, raised to the power of 0.8, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity + (logarithm ** 0.8)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function assigns items to bins based on the maximum score, while avoiding using bins at maximum capacity in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == np.max(bins)] = -1\\n scores = remaining_capacity / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with more remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, bins - item) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will assign a score to each bin based on the remaining capacity after placing the item. The score will be calculated by taking the reciprocal of the difference between the bin capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity. Higher scores indicate better candidates for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.15595,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm calculates the score for each bin based on the rest capacity and assigns the item to the bin with the maximum score, aiming to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = np.maximum(0, max_capacity - bins) # Calculate rest capacity\\n mask = rest_capacity < item # Check if rest capacity is enough for the item\\n rest_capacity[mask] = 0 # Set rest capacity to 0 if it's not enough\\n scores = rest_capacity / (max_capacity * (1 - mask)) # Calculate scores for each bin\\n return scores\",\n \"objective\": 0.31975,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the score for each bin by taking the ratio of the rest capacity to the item size, and then subtracting 1 if the rest capacity equals the maximum capacity, in order to prioritize the bin with the largest available space but not the maximum capacity, with the main steps being to calculate the scores and return them as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm as follows:\\nThe algorithm will calculate the score for each bin based on the remaining capacity after assigning the item, with a penalty for bins at maximum capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) - (bins == bins.max()) * (item + 1)\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the remaining capacity of each bin after assigning the item, and then assigns a score to each bin based on the ratio of remaining capacity to the maximum capacity, with a penalty for bins with maximum capacity. It then returns the scores for all bins using Numpy array. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_ratio = remaining_capacity / np.max(bins)\\n remaining_ratio[bins == np.max(bins)] -= 0.5 # Apply penalty for bins with maximum capacity\\n scores = remaining_ratio\\n return scores\",\n \"objective\": 0.40739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves ranking the bins based on their remaining capacity after assigning the item, and penalizing bins with maximum capacity to discourage their use. First, calculate the remaining capacity of each bin after assigning the item, then calculate the score for each bin by considering its remaining capacity and penalizing bins with maximum capacity. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalized_capacity = np.where(remaining_capacity < np.max(remaining_capacity), remaining_capacity, np.max(remaining_capacity) * 2)\\n scores = penalized_capacity * (1 + np.log(1 + np.abs(penalized_capacity - np.max(penalized_capacity))))\\n return scores\",\n \"objective\": 0.5735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the minimum between the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.maximum(bins - item, 0)\\n scores = np.minimum(capacities, item)\\n return scores\",\n \"objective\": 0.64021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: First, calculate the free space in each bin after adding the item, then compute the score for each bin using a novel formula that takes into account the free space and the distance from the maximum capacity, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_space = bins - item\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - remaining_space\\n scores = remaining_space * (1 + distance_from_max)\\n return scores\",\n \"objective\": 0.77412,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the following formula: score = (bin_capacity - item_size) * (1 - bin_index/N), where N is the total number of bins. Then, the function will return the scores for each bin in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n scores = (bins - item) * (1 - np.arange(N)/N)\\n return scores\",\n \"objective\": 0.89174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacity of each bin after adding the item, and then scores each bin based on the formula: ((maximum capacity - available capacity) / maximum capacity) * available capacity, where bins with the maximum capacity are not scored. Finally, the function returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n available_capacity = np.maximum(0, (bins + item) - max_capacity)\\n scores = ((max_capacity - available_capacity) / max_capacity) * available_capacity\\n scores[available_capacity == 0] = 0\\n return scores\",\n \"objective\": 1.21401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplementing the algorithm:\\n1. Create a function named score that accepts two input parameters: 'item' and 'bins'.\\n2. Inside the function, calculate the scores for each bin by first finding the difference between the maximum capacity of each bin and the size of the item.\\n3. For bins that have a rest capacity equal to the maximum capacity, assign a score of -1 to make them ineligible for item assignment.\\n4. Return the calculated scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == bins.max()).astype(int) * -1\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm: The algorithm first calculates the scores for each bin based on the rest capacity and the current item size, then it returns the scores for the bins for assignment.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0)\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the difference between capacities of adjacent bins.\\n\\nNew algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the position of the bin in the sorted order of capacities, and a penalty term for bins close to their maximum capacity while avoiding their usage, with the goal of minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n bin_positions = np.argsort(bins)\\n scores = (rest_capacities / np.arange(1, len(sorted_bins) + 1)) + (bin_positions / (bin_positions.max() + 1))\\n\\n max_capacity = np.max(bins)\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == max_capacity] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.max(bins) - item\\n scores = (1 / (np.arange(len(bins)) + 1)) * remaining_capacity\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and the bin positions, while penalizing bins at maximum capacity and avoiding their usage.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = (rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)\\n scores[bins == max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n \\n bin_positions = np.arange(1, len(bins) + 1)\\n scores += bin_positions # Adding bin positions to scores\\n \\n return scores\",\n \"objective\": 0.04377,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to maximize the utilization of each bin while minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.max(bins) - item\\n scores = (bins / remaining_capacity) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the difference between capacities of adjacent bins.\\n\\nNew algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the position of the bin in the sorted order of capacities, and a penalty term for bins close to their maximum capacity while avoiding their usage, with the goal of minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == bins.max()] = -1\\n bin_positions = np.argsort(bins) + 1\\n scores = (rest_capacities / bin_positions) + (bin_positions / (np.max(bin_positions)))\\n\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == bins.max()] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.04568,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin based on a combination of factors including the remaining capacity of the bin, the proximity to the item size, the difference between the capacities of adjacent bins, and the bin positions. It penalizes bins based on their remaining capacity and avoids using bins that have a remaining capacity equal to the maximum capacity. The final scores are returned as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n \\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores = (\\n (max_capacity - bins) + \\n (bins != max_capacity) * (\\n (bins - item) * (item < bins) +\\n (bins - item) * (item >= bins) * (bins != min_capacity)\\n ) - \\n (bins == max_capacity) * item * 1000\\n )\\n\\n scores[1:] -= np.abs(np.diff(bins))\\n \\n bin_positions = np.arange(1, len(bins) + 1)\\n scores += bin_positions\\n \\n scores -= np.abs(max_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, and the difference between the capacities of adjacent bins, while penalizing bins at maximum capacity and avoiding their usage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = (rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)\\n scores[bins == max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n return scores\",\n \"objective\": 0.04679,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the ratio of the remaining capacity to the item size, penalizing bins at maximum capacity, and promoting the utilization of bins with smaller differences in capacities.\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / item) - (bins == max(bins)) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n return scores\",\n \"objective\": 0.04809,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on a combination of factors including the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the position of the bin in the sorted order of capacities, and a penalty term for bins close to their maximum capacity while avoiding their usage, with the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n bin_positions = np.argsort(bins)\\n differences = np.diff(sorted_bins)\\n differences = np.append(differences, 0) \\n \\n scores = (rest_capacities / np.arange(1, len(sorted_bins) + 1)) + (bin_positions / (bin_positions.max() + 1)) + (differences / (differences.max() + 1))\\n \\n max_capacity = np.max(bins)\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == max_capacity] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.0497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and the bin positions, while also penalizing bins based on their remaining capacity, and avoiding their usage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores = ((max_capacity - bins) + \\n (bins == max_capacity) * item - \\n (bins == min_capacity) * item)\\n \\n scores -= (bins == max_capacity) * item * 1000\\n \\n scores[1:] -= np.abs(np.diff(bins))\\n \\n bin_positions = np.arange(1, len(bins) + 1)\\n scores += bin_positions # Adding bin positions to scores\\n \\n scores -= np.abs(max_capacity - bins) # Penalizing bins based on their remaining capacity\\n \\n return scores\",\n \"objective\": 0.05212,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, and the difference between the capacities of adjacent bins, while penalizing bins at maximum capacity and avoiding their usage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n sorted_bins = np.sort(bins)\\n scores = (rest_capacities - np.min(rest_capacities)) / np.arange(1, len(sorted_bins) + 1)\\n scores[bins == max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(sorted_bins))\\n return scores\",\n \"objective\": 0.05343,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and a penalty for bins at maximum and minimum capacity, with the aim of minimizing the number of used bins while considering all these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores = ((max_capacity - bins) + \\n (bins == max_capacity) * item - \\n (bins == min_capacity) * item)\\n \\n scores -= (bins == max_capacity) * item * 1000\\n \\n return scores\",\n \"objective\": 0.05373,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and a penalty for bins at maximum and minimum capacity, with the aim of minimizing the number of used bins while considering all these factors.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n diff_capacity = np.diff(bins)\\n \\n scores = ((max_capacity - bins) + \\n (bins == max_capacity) * item - \\n (bins == min_capacity) * item)\\n \\n scores[1:] -= np.abs(diff_capacity)\\n scores -= (bins == max_capacity) * item * 1000\\n \\n return scores\",\n \"objective\": 0.05463,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the bin positions, and a penalty term for bins close to their maximum capacity while avoiding their usage.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = (rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)\\n scores[bins == max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n \\n bin_positions = np.arange(1, len(bins) + 1)\\n scores += bin_positions # Adding bin positions to scores\\n \\n max_capacity = np.max(bins)\\n scores -= (bins - np.mean(bins)) / np.std(bins) # Penalty term for bins close to their maximum capacity\\n \\n scores[bins == max_capacity] -= np.max(rest_capacities) * 1000 # Penalty term for bins at maximum capacity\\n \\n return scores\",\n \"objective\": 0.05494,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nThe algorithm assigns scores to each bin based on their remaining capacity and their proximity to the item size, while penalizing bins at maximum capacity and avoiding their usage. It also takes into account the difference in capacities between adjacent bins and further penalizes bins at maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n diff_capacity = np.diff(bins)\\n remaining_capacity = bins - item\\n\\n scores = ((max_capacity - bins) / bins +\\n (remaining_capacity / bins)**2 +\\n (bins == max_capacity) * item -\\n (bins == min_capacity) * item)\\n\\n scores[1:] -= np.abs(diff_capacity)\\n scores -= (bins == max_capacity) * item * 1000\\n\\n return scores\",\n \"objective\": 0.05514,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their remaining capacity and their proximity to the item size, while penalizing bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm: The scores are calculated for each bin based on the remaining capacity, the ratio of remaining capacity to bin capacity, the difference between the bin capacities, and a penalty for bins at maximum capacity and minimum capacity, aiming to minimize the number of used bins while considering all these factors.\\n\\nHere is the implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n diff_capacity = np.diff(bins)\\n \\n scores = ((max_capacity - bins) / bins +\\n (bins == max_capacity) * item -\\n (bins == min_capacity) * item)\\n \\n scores[1:] -= np.abs(diff_capacity)\\n scores -= (bins == max_capacity) * item * 1000\\n \\n return scores\",\n \"objective\": 0.05564,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the score for each bin based on the remaining capacity, the proximity to the item size, and the position of the bin in the sorted order of capacities, penalizing bins at maximum capacity while avoiding their usage, and considering the difference between the capacities of adjacent bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n scores[bins == max(bins)] -= 1000\\n scores[1:] -= np.abs(np.diff(sorted_bins))\\n return scores\",\n \"objective\": 0.05654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, and the difference between the capacities of adjacent bins, while penalizing bins at maximum capacity and avoiding their usage.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n scores = (rest_capacities - np.min(rest_capacities)) / np.arange(1, len(sorted_bins) + 1)\\n scores[bins == max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(sorted_bins))\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity + item) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher sum values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n sum_scores = (remaining_capacity % item) * np.log(remaining_capacity) + np.sqrt(item / remaining_capacity) + np.exp(item * remaining_capacity)\\n \\n scores = sum_scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n remaining_capacity_normalized = remaining_capacity / max_capacity\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity_normalized)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an additional penalty for bins that have a capacity within a certain range of the item size. Additionally, it takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio.\\n\\nHere is the modified code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 1) & (bins <= item + 1)\\n ratio_penalty = (max_capacity - bins) / item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - ratio_penalty\\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an additional penalty for bins that have a capacity within a certain range of the item size.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 1) & (bins <= item + 1)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the product of the remaining capacity and the square root of the item size, minus the sum of the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the logarithm of the remaining capacity squared, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = (rest_capacities * np.sqrt(item)) - np.sum(np.abs(np.diff(bins)))\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores -= np.log(np.square(rest_capacities))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the logarithm of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = 1 / np.arange(1, len(bins) + 1)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores -= np.log(rest_capacities)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the logarithm of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.log(rest_capacities)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, penalties for bins at maximum capacity and for avoiding their usage, and a penalty based on the sum of the remaining capacities of all the bins. It will also introduce a new factor, which is the product of the remaining capacity and the item size, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sum(bins[bins != np.max(bins)]) * np.square(rest_capacities) / np.sum(rest_capacities)\\n scores -= item * rest_capacities\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the square of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, c=10, k=1):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.full(len(bins), c)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= k * np.max(rest_capacities)\\n scores[1:] -= np.abs(np.diff(bins))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and a penalty for bins at maximum capacity, aiming to minimize the number of used bins. It also introduces a new factor, which is the square root of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on a combination of factors including the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, penalties for bins at maximum capacity and avoiding their usage, and a new factor that penalizes bins with high remaining capacity and encourages bin utilization. It will also introduce a non-linear transformation of the remaining capacity using a sigmoid function to further adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef sigmoid(x):\\n return 1 / (1 + np.exp(-x))\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= sigmoid(rest_capacities)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the square of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the ratio between the remaining capacities and the item size, and the position of the bin in the sorted order of capacities, aiming to minimize the number of used bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n rest_ratios = rest_capacities / item\\n bin_positions = np.argsort(bins) + 1\\n scores = (rest_capacities / bin_positions) + (bin_positions / (np.max(bin_positions))) - (rest_ratios * item)\\n\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == bins.max()] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the difference between capacities of adjacent bins.\\n\\nNew algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, a penalty for bins at maximum capacity and avoiding their usage, and a new factor that penalizes bins with high remaining capacity and encourages bin utilization. The new factor will be the exponential function of the remaining capacity multiplied by the inverse of the square of the bin index to prioritize filling bins with lower indices first.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.exp(rest_capacities) * (1 / (np.arange(1, len(bins) + 1) ** 2))\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, a penalty for bins at maximum capacity and avoiding their usage, and a new factor that penalizes bins with high remaining capacity and encourages bin utilization. The new factor will be the square root of the remaining capacity divided by the square of the bin index to prioritize filling bins with lower indices first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the difference between capacities of adjacent bins.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, prioritize bins with larger remaining capacity, penalize bins at maximum capacity, incorporate a term for the position of each bin in the sorted order of capacities to adjust the scores, and introduce a penalty for bins that are far from the item size, aiming to minimize the number of used bins and maximize overall utilization while maintaining self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n max_capacity = np.max(sorted_bins)\\n rest_capacities = sorted_bins - item\\n\\n scores = (rest_capacities / max_capacity)\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == max_capacity] -= np.max(rest_capacities) * 1000\\n\\n diff_from_item = np.abs(sorted_bins - item)\\n scores -= diff_from_item\\n\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the difference between capacities of adjacent bins.\\n\\nNew algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the position of the bin in the sorted order of capacities, and a penalty term for bins close to their maximum capacity while avoiding their usage, with the goal of minimizing the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n bin_positions = np.argsort(bins)\\n scores = (rest_capacities / np.arange(1, len(sorted_bins) + 1)) + (bin_positions / (bin_positions.max() + 1))\\n\\n max_capacity = np.max(bins)\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == max_capacity] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the ratio between the remaining capacities and the item size, the position of the bin in the sorted order of capacities, and penalties for bins at maximum capacity, aiming to minimize the number of used bins and promote overall utilization while maintaining self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n max_capacity = np.max(sorted_bins)\\n bin_positions = np.argsort(bins) + 1\\n rest_capacities = sorted_bins - item\\n rest_ratios = rest_capacities / item\\n\\n scores = (rest_capacities / max_capacity) + (bin_positions / (np.max(bin_positions))) - (rest_ratios * item)\\n\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == max_capacity] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Identifying the common backbone idea in the provided algorithms:\\n\\nThe common backbone idea in the provided algorithms is to calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the difference between the capacities of adjacent bins.\\n\\nNew Algorithm: The score function will calculate scores for each bin based on the remaining capacity, prioritize bins with larger remaining capacity, penalize bins at maximum capacity, and incorporate a term for the position of each bin in the sorted order of capacities, while also considering the difference between capacities of adjacent bins and promoting overall utilization by taking into account the square of the remaining capacity, aiming to minimize the number of used bins and maximize the overall utilization.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n max_capacity = np.max(sorted_bins)\\n bin_positions = np.argsort(bins) + 1\\n rest_capacities = sorted_bins - item\\n \\n scores = ((rest_capacities - np.min(rest_capacities)) / np.full(len(bins), 10)) - np.square(rest_capacities)\\n scores += (bin_positions / (np.max(bin_positions))) - (1 / bin_positions)\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n \\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate scores for each bin based on the remaining capacity, prioritize bins with larger remaining capacity, penalize bins at maximum capacity, incorporate a term for the position of each bin in the sorted order of capacities to further adjust the scores for each bin, add a penalty based on the square root of the rest capacity to favor bins with more available space, and finally, subtract a penalty based on the square of the bin position to encourage placing items in lower position bins, aiming to minimize the number of used bins and maximize overall utilization while maintaining self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n max_capacity = np.max(sorted_bins)\\n bin_positions = np.argsort(bins) + 1\\n rest_capacities = sorted_bins - item\\n\\n scores = (\\n (rest_capacities / max_capacity) + \\n (bin_positions / np.max(bin_positions)) - \\n (1 / bin_positions) +\\n np.sqrt(rest_capacities) - \\n (bin_positions**2)\\n )\\n\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == max_capacity] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the harmonic mean of the item size and the remaining capacity, the square root of the logarithm of the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n harmonic_mean = 2 / (1/item + 1/remaining_capacity)\\n sqrt_log_capacity = np.sqrt(np.log(remaining_capacity))\\n \\n scores = harmonic_mean * sqrt_log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the factor of the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, and penalties for bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm description: The new algorithm will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\\n\\nNew algorithm implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.02334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the sum of the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an additional penalty for bins that have a capacity within a certain range of the item size. Additionally, it takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio, but with a different parameter setting.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 2) & (bins <= item + 2) # expanded range of penalty\\n ratio_penalty = (max_capacity - bins) / (item + 1) # increased penalty for smaller ratio\\n scores = (max_capacity - bins) + (bins == max_capacity) * (item + 1) + range_penalty * max_capacity - ratio_penalty\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a larger penalty for bins at maximum capacity, and a smaller penalty for bins that have a capacity within a certain range of the item size. Additionally, it takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio and giving a slight bonus to bins with a larger ratio.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 2) & (bins <= item + 2)\\n ratio_penalty = (max_capacity - bins) / item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - (bins > max_capacity / item) * ratio_penalty * 0.5 + (bins < max_capacity / item) * ratio_penalty * 0.1\\n return scores\",\n \"objective\": 0.03552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an additional penalty for bins that have a capacity within a certain range of the item size. Additionally, it takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio.\\n\\nHere is the modified code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 1) & (bins <= item + 1)\\n ratio_penalty = (max_capacity - bins) / item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - ratio_penalty\\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, an additional penalty for bins that have a capacity within a certain range of the item size, and takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio. The new algorithm also introduces a weight for each penalty, allowing for more flexibility in parameter settings.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 1) & (bins <= item + 1)\\n ratio_penalty = (max_capacity - bins) / item\\n \\n # New parameter settings\\n max_capacity_penalty = 1 # Penalty for bins at maximum capacity\\n range_penalty_weight = 2 # Additional penalty weight for bins in the specified range\\n ratio_penalty_weight = 0.5 # Penalty weight for the ratio of remaining capacity to item size\\n \\n scores = (max_capacity - bins) * max_capacity_penalty + (bins == max_capacity) * item * max_capacity_penalty + range_penalty * max_capacity * range_penalty_weight - ratio_penalty * ratio_penalty_weight\\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an additional penalty for bins that have a capacity within a certain range of the item size.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 1) & (bins <= item + 1)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the product of the remaining capacity and the square root of the item size, minus the sum of the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the logarithm of the remaining capacity squared, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = (rest_capacities * np.sqrt(item)) - np.sum(np.abs(np.diff(bins)))\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores -= np.log(np.square(rest_capacities))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the logarithm of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = 1 / np.arange(1, len(bins) + 1)\\n scores -= np.log(rest_capacities)\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the logarithm of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.log(rest_capacities)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms calculate scores for each bin based on the remaining capacity and consider penalties for bins at maximum capacity or within a certain range of the item size.\\n\\nNew Algorithm Description: The new algorithm assigns scores to each bin based on the inverse of the ratio between the remaining capacity and the item size, penalizing bins with smaller ratios, and introducing a factor that encourages the utilization of bins with lower indices.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = (bins - item) / item\\n scores = 1 / ratios\\n scores[bins == np.max(bins)] -= np.max(bins) * 1000\\n scores -= np.arange(1, len(bins) + 1) / item\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the logarithm of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = 1 / bins\\n scores -= np.log(rest_capacities)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the exponential of the remaining capacity squared, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.exp(np.square(rest_capacities))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the square of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, c=5, k=2):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.full(len(bins), c)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= k * np.max(rest_capacities)\\n scores[1:] -= np.abs(np.diff(bins))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and a penalty for bins at maximum capacity, aiming to minimize the number of used bins. It also introduces a new factor, which is the square root of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on a combination of factors including the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, penalties for bins at maximum capacity and avoiding their usage, and a new factor that penalizes bins with high remaining capacity and encourages bin utilization. It will also introduce a non-linear transformation of the remaining capacity using a sigmoid function to further adjust the scores.\",\n \"code\": \"import numpy as np\\n\\ndef sigmoid(x):\\n return 1 / (1 + np.exp(-x))\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= sigmoid(rest_capacities)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, and penalties for bins at maximum capacity and avoiding their usage. It will also introduce a new factor, which is the square of the remaining capacity, to further penalize bins with high remaining capacity and encourage bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate scores for each bin based on the proximity to the item size, the ratio between the remaining capacities and the item size, and the position of the bin in the sorted order of capacities, aiming to minimize the number of used bins. The scoring will be adjusted based on the standard deviation of the rest capacities, assigning higher scores to bins with lower deviation. The scores will be further modified by subtracting a penalty if the bin has the maximum capacity, making it less likely to be used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n rest_capacities = sorted_bins - item\\n rest_ratios = rest_capacities / item\\n bin_positions = np.argsort(bins) + 1\\n scores = rest_capacities / bin_positions + bin_positions / np.max(bin_positions) - rest_ratios * item\\n\\n scores -= (bins - np.mean(bins)) / np.std(bins)\\n scores[bins == bins.max()] -= np.max(rest_capacities) * 1000\\n\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the difference between capacities of adjacent bins.\\n\\nNew algorithm: The score function will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, a penalty for bins at maximum capacity and avoiding their usage, and a new factor that penalizes bins with high remaining capacity and encourages bin utilization. The new factor will be the exponential function of the remaining capacity multiplied by the inverse of the square of the bin index to prioritize filling bins with lower indices first.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[bins == np.max(bins)] -= np.max(rest_capacities) * 1000\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.exp(rest_capacities) * (1 / (np.arange(1, len(bins) + 1) ** 2))\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, a penalty for bins at maximum capacity and avoiding their usage, and a new factor that penalizes bins with high remaining capacity and encourages bin utilization. The new factor will be the square root of the remaining capacity divided by the square of the bin index to prioritize filling bins with lower indices first.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.square(rest_capacities)\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity, while also considering the ratios of the remaining capacity to the item size. \\n\\nNew algorithm implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n ratios = (rest_capacities / item)\\n scores -= ratios / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, and penalties for bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm description: The new algorithm will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\\n\\nNew algorithm implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity first and penalizing bins with lower indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n # Add a new factor to prioritize higher remaining capacity bins and penalize lower index bins\\n scores += np.arange(len(bins)) / np.square(rest_capacities)\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, and penalties for bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n # Add a new factor to prioritize lower index bins and penalize high remaining capacity bins\\n scores -= np.arange(len(bins)) / np.square(rest_capacities)\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the sum of the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = (rest_capacities / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, the sum of the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that discourages bin utilization by penalizing bins with lower indices first and prioritizing bins with high remaining capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n ratio_penalty = (rest_capacities / item)\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= ratio_penalty\\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, and penalties for bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm description: The new algorithm will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\\n\\nNew algorithm implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.02334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the sum of the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.02385,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, the sum of the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with higher indices first and penalizing bins with high remaining capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n ratio_penalty = 1 / (rest_capacities / item)\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores += np.sqrt(rest_capacities) / (np.arange(len(bins), 0, -1) ** 2)\\n scores -= ratio_penalty\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity. The new algorithm should also consider the ratio of remaining capacity to the item size.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n ratio_penalty = (rest_capacities / item)\\n scores -= ratio_penalty\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description of the new algorithm: The new algorithm calculates the scores for each bin based on the remaining capacity, with an increased penalty for bins at maximum capacity, and a decreased penalty for bins that have a capacity within a certain range of the item size. Additionally, it takes into account the ratio of remaining capacity to the item size, penalizing bins with a larger ratio, with a different parameter setting.\\n\\nCode for the new score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 2) & (bins <= item + 2) # wider range of penalty\\n ratio_penalty = (max_capacity - bins) / (item + 1) # increased penalty for larger ratio\\n scores = (max_capacity - bins) + (bins == max_capacity) * (item + 3) + range_penalty * max_capacity - ratio_penalty\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on the remaining capacity, penalizing bins at maximum capacity and bins with capacities within a certain range of the item size. It also takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio. The algorithm aims to minimize the number of used bins.\",\n \"code\": \"def score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 5) & (bins <= item + 5)\\n ratio_penalty = (max_capacity - bins) / item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - ratio_penalty * 3\\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The new algorithms calculate scores for each bin based on the remaining capacity, penalize bins at maximum capacity, and consider the ratio of remaining capacity to the item size.\\n\\nNew algorithm: The new algorithm calculates scores for each bin based on the remaining capacity, with different penalties and bonuses for bins at maximum capacity, bins within a certain range of the item size, bins with a smaller ratio of remaining capacity to the item size, and bins with capacities that are a multiple of the item size.\\n\\nCode for the new score function:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 4) & (bins <= item + 4) # wider range of penalty\\n ratio_penalty = (max_capacity - bins) / item # increased penalty for smaller ratio\\n multiple_bonus = (bins % item == 0) * item / 3 # increased bonus for multiple of item size\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - 2*ratio_penalty + 2*multiple_bonus\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate scores for each bin based on the remaining capacity and apply penalties or bonuses based on certain conditions or ratios.\\n\\nNew algorithm idea: The new algorithm calculates the scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, and the difference between the capacities of adjacent bins, while also taking into account a penalty for bins at maximum capacity and prioritizing bins with higher remaining capacity and lower indices.\\n\\nNew algorithm implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n ratio_penalty = (rest_capacities / item)\\n scores = ((rest_capacities - min_capacity) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= ratio_penalty\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an additional penalty for bins that have a capacity within a certain range of the item size. Additionally, it takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio, but with a different parameter setting.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 1) & (bins <= item + 1) # narrow range of penalty\\n ratio_penalty = (max_capacity - bins) / (item + 2) # decreased penalty for smaller ratio\\n scores = (max_capacity - bins) + (bins == max_capacity) * (item + 2) + range_penalty * max_capacity - ratio_penalty\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate scores for each bin based on the remaining capacity and apply penalties or bonuses based on certain conditions or ratios.\\n\\nNew algorithm: The new algorithm calculates the scores for each bin based on the remaining capacity, with penalties for bins at maximum capacity and bins with capacities within a certain range of the item size. It also takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio.\\n\\nHere is the modified code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 3) & (bins <= item + 3)\\n ratio_penalty = (max_capacity - bins) / item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - ratio_penalty * 2\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the remaining capacity, with penalties for bins at maximum capacity and bins with capacities within a certain range of the item size. It also takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio, and incorporates a bonus for bins with a capacity that is a multiple of the item size. Additionally, it considers the ratio of remaining capacity to the sum of all bin capacities, penalizing bins with a smaller ratio. The new algorithm modifies the parameter values to adjust the penalties and bonuses, providing different weightings to the different conditions.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 2) & (bins <= item + 2)\\n ratio_penalty = (max_capacity - bins) / item\\n multiple_bonus = (bins % item == 0) * item / 2\\n ratio_to_sum_penalty = (max_capacity - bins) / np.sum(bins)\\n # Adjust the parameter values below to modify the penalties and bonuses\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - 2*ratio_penalty + 2*multiple_bonus - 0.5*ratio_to_sum_penalty\\n return scores\",\n \"objective\": 0.0331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an additional penalty for bins that have a capacity within a certain range of the item size. It also takes into account the ratio of remaining capacity to the item size, penalizing bins with a smaller ratio. The algorithm further incorporates a bonus for bins with a capacity that is a multiple of the item size.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 2) & (bins <= item + 2) # expanded range of penalty\\n ratio_penalty = (max_capacity - bins) / (item + 1) # increased penalty for smaller ratio\\n multiple_bonus = (bins % item == 0) * item/2 # bonus for bins with capacity multiple of item size\\n scores = (max_capacity - bins) + (bins == max_capacity) * (item + 1) + range_penalty * max_capacity - ratio_penalty + multiple_bonus\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, penalizes bins at maximum capacity and bins within a certain range of the item size, takes into account the ratio of remaining capacity to the item size, penalizes bins with a smaller ratio, and incorporates a bonus for bins with capacities that are a multiple of the item size.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 3) & (bins <= item + 3)\\n ratio_penalty = (max_capacity - bins) / item\\n multiple_bonus = (bins % item == 0) * item/2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - ratio_penalty + multiple_bonus\\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first, penalizing bins with high remaining capacity, and providing a bonus for bins with capacities that are a multiple of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n range_penalty = (bins >= item - 4) & (bins <= item + 4) # wider range of penalty\\n ratio_penalty = (max_capacity - bins) / item # increased penalty for smaller ratio\\n multiple_bonus = (bins % item == 0) * item / 3 # increased bonus for multiple of item size\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + range_penalty * max_capacity - ratio_penalty + multiple_bonus\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm will calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, avoiding their usage, and a new factor that promotes bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower index.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n # Add a new factor to prioritize higher remaining capacity bins and penalize lower index bins\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, proximity to the item size, penalties for bins at maximum capacity, and a new factor that gives higher priority to bins with lower remaining capacity and penalizes bins with higher indices.\\n\\nHere is the modified code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n num_bins = len(bins)\\n min_capacity = np.min(rest_capacities)\\n indices = np.arange(1, num_bins + 1)\\n \\n scores = (rest_capacities - min_capacity) / indices\\n scores -= np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (indices ** 2)\\n scores += np.square(1 / (rest_capacities + 1)) / indices\\n\\n # New factor: higher priority to lower remaining capacity bins\\n scores -= np.sqrt(rest_capacities) / indices\\n\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, avoiding their usage, and introduces a new factor that considers the ratio of the remaining capacity to the item size, while also prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.log(rest_capacities / item)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, penalties for bins at maximum capacity, and a new factor that encourages bin utilization by penalizing bins with high remaining capacity and lower indices first, while also considering the average proximity to the item size and the difference between the maximum and minimum capacities.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n diff_capacities = np.diff(bins)\\n max_capacity = np.max(rest_capacities)\\n min_capacity = np.min(rest_capacities)\\n\\n scores = ((rest_capacities - max_capacity) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.flip(diff_capacities)\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / np.square(np.arange(len(bins), 0, -1))\\n scores -= np.sqrt(max_capacity / min_capacity) / np.arange(len(bins), 0, -1)\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower indices, and an additional factor that considers the difference between the maximum and minimum capacities, the average proximity to the item size, and the square root of the remaining capacity.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n diff_capacities = np.diff(bins)\\n max_capacity = np.max(rest_capacities)\\n min_capacity = np.min(rest_capacities)\\n\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= np.square(1 / (rest_capacities + 1)) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(max_capacity / min_capacity) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(np.mean(proximity)) / (np.arange(1, len(bins) + 1) ** 2)\\n scores += np.sqrt(rest_capacities) / (np.arange(len(bins), 0, -1) ** 2)\\n \\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and introduces a new factor that considers the ratio of the remaining capacity to the item size, while also prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n size_ratio = (bins - item) / item\\n indices = np.arange(len(bins), 0, -1)\\n \\n scores = ((bins - item) / indices) - np.log(np.square(bins - item))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (indices + 1))\\n scores += np.square(bins - item) / indices\\n scores -= np.log(size_ratio)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity, while also considering the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n ratio_penalty = (rest_capacities / item)\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= ratio_penalty / (np.arange(1, len(bins) + 1) ** 3)\\n scores -= np.power(np.max(bins) - rest_capacities, 2) / np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, the square of the remaining capacity, and a factor that promotes bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n proximity = np.abs(remaining_capacities - item)\\n scores = ((remaining_capacities - np.min(remaining_capacities)) / np.arange(1, len(bins) + 1)) - np.log(remaining_capacities ** 2)\\n scores += np.square(remaining_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, avoiding their usage, and a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower index.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n # Add a new factor to prioritize higher remaining capacity bins and penalize lower index bins\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, a factor that promotes bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower indices, and a factor that considers the ratio of the remaining capacity to the item size. It also incorporates a modified version of the existing algorithm to further optimize performance.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n proximity = np.abs(remaining_capacities - item)\\n scores = ((remaining_capacities - np.min(remaining_capacities)) / np.arange(1, len(bins) + 1)) - np.log(remaining_capacities ** 2)\\n scores += np.square(remaining_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / (np.arange(1, len(bins) + 1) ** 2)\\n scores += remaining_capacities / item\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 2))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, and penalties for bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, a factor that encourages bin utilization by prioritizing bins with lower indices first, and a new factor that promotes bin utilization by prioritizing bins with higher remaining capacity.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n diff_capacities = np.diff(bins)\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.flip(diff_capacities)\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) +1))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores += np.exp(-proximity) / (np.arange(len(bins), 0, -1) ** 2)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, penalties for bins at maximum capacity, and a new factor that encourages bin utilization by penalizing bins with high remaining capacity and lower indices first, while also considering the average proximity to the item size and the difference between the maximum and minimum capacities.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity, while also considering the ratios of the remaining capacity to the item size. \\n\\nNew algorithm implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n ratios = (rest_capacities / item)\\n scores -= ratios / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, and penalties for bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm description: The new algorithm will calculate scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity.\\n\\nNew algorithm implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, penalties for bins at maximum capacity, a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower index, and a factor that considers the difference between the maximum and minimum capacities, the average proximity to the item size, and the square root of the remaining capacity, while also incorporating a modified version of the existing algorithm to promote performance. The algorithm aims to minimize the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n diff_capacities = np.diff(bins)\\n max_capacity = np.max(rest_capacities)\\n min_capacity = np.min(rest_capacities)\\n num_bins = len(bins)\\n indices = np.arange(1, num_bins + 1)\\n \\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / np.square(np.arange(len(bins), 0, -1))\\n scores -= np.sqrt(max_capacity / min_capacity) / np.arange(len(bins), 0, -1)\\n scores += ((rest_capacities - np.min(rest_capacities)) / indices)\\n scores -= np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (indices ** 2)\\n scores += np.square(1 / (rest_capacities + 1)) / indices\\n\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, penalties for bins at maximum capacity, and a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower index. Additionally, it incorporates a factor that considers the difference between the maximum and minimum capacities, the average proximity to the item size, and the square root of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n diff_capacities = np.diff(bins)\\n max_capacity = np.max(rest_capacities)\\n min_capacity = np.min(rest_capacities)\\n\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / np.square(np.arange(len(bins), 0, -1))\\n scores -= np.sqrt(max_capacity / min_capacity) / np.arange(len(bins), 0, -1)\\n \\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, proximity to the item size, and penalties for bins at maximum capacity. Additionally, it introduces a new factor that gives higher priority to bins with lower remaining capacity and penalizes bins with higher indices. The algorithm also incorporates a modified version of the existing algorithm to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n num_bins = len(bins)\\n min_capacity = np.min(rest_capacities)\\n indices = np.arange(1, num_bins + 1)\\n \\n scores = (rest_capacities - min_capacity) / indices\\n scores -= np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (indices ** 2)\\n scores += np.square(1 / (rest_capacities + 1)) / indices\\n\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity first and penalizing bins with lower indices, and an additional factor that penalizes bins with very close capacities to maximum capacity.\\n\\nNew algorithm implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.abs(rest_capacities - np.max(rest_capacities))\\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity first and penalizing bins with lower indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n # Add a new factor to prioritize higher remaining capacity bins and penalize lower index bins\\n scores += np.arange(len(bins)) / np.square(rest_capacities)\\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the difference between the capacities of adjacent bins, the proximity to the item size, the logarithm of the remaining capacity squared, and a new factor that discourages bin utilization by penalizing bins with higher indices first and prioritizing bins with lower remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n diff_capacities = np.diff(bins)\\n proximity = np.abs(rest_capacities - item)\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.flip(diff_capacities)\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n scores += np.exp(-proximity) / (np.arange(len(bins), 0, -1) ** 2)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin by considering the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and a new factor that encourages bin utilization by prioritizing bins with lower indices first, penalizing bins with high remaining capacity, and considering the ratio of the remaining capacity to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 2))\\n scores -= np.sqrt(proximity) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the square root of the difference between the rest capacity and the item size, penalties for bins at maximum capacity, and an additional penalty for bins with higher indices. \\n\\nHere is the modified code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n num_bins = len(bins)\\n max_capacity = np.max(rest_capacities)\\n indices = np.arange(1, num_bins + 1)\\n \\n scores = rest_capacities / np.sqrt(np.abs(rest_capacities - item))\\n scores -= np.log(np.square(rest_capacities))\\n scores -= np.square(indices) / (rest_capacities + 1)\\n scores -= np.sqrt(indices) / (max_capacity + 1)\\n\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm and main steps:\\nThe new algorithm calculates scores for each bin based on the remaining capacity, proximity to the item size, penalties for bins at maximum capacity, and a new factor that gives higher priority to bins with lower remaining capacity and penalizes bins with higher indices. Additionally, it introduces a new parameter setting for the score function.\\n\\nHere is the modified code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n num_bins = len(bins)\\n min_capacity = np.min(rest_capacities)\\n indices = np.arange(1, num_bins + 1)\\n \\n scores = (rest_capacities - min_capacity) / indices\\n scores -= np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (indices ** 2)\\n scores += np.square(1 / (rest_capacities + 1)) / indices\\n\\n # New factor: higher priority to lower remaining capacity bins\\n scores -= np.sqrt(rest_capacities) / indices\\n\\n # Additional parameter setting\\n scores *= np.exp(-0.1 * (num_bins - indices))\\n\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity, while also considering the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n ratio_penalty = rest_capacities\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= ratio_penalty / (np.arange(1, len(bins) + 1) ** 3)\\n scores -= np.power(np.max(bins) - rest_capacities, 2) / np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm will calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, avoiding their usage, and a new factor that promotes bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower index.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n # Add a new factor to prioritize higher remaining capacity bins and penalize lower index bins\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, proximity to the item size, penalties for bins at maximum capacity, and a new factor that gives higher priority to bins with lower remaining capacity and penalizes bins with higher indices.\\n\\nHere is the modified code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n num_bins = len(bins)\\n min_capacity = np.min(rest_capacities)\\n indices = np.arange(1, num_bins + 1)\\n \\n scores = (rest_capacities - min_capacity) / indices\\n scores -= np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (indices ** 2)\\n scores += np.square(1 / (rest_capacities + 1)) / indices\\n\\n # New factor: higher priority to lower remaining capacity bins\\n scores -= np.sqrt(rest_capacities) / indices\\n\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, avoiding their usage, and introduces a new factor that considers the ratio of the remaining capacity to the item size, while also prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.log(rest_capacities / item)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the remaining capacity, penalties for bins at maximum capacity, and a factor related to the ratio of the remaining capacity to the item size.\\nNew algorithm description: The new algorithm calculates scores for each bin by considering the remaining capacity, the proximity to the item size, and introducing a factor related to the inverse of the ratio of the remaining capacity to the item size.\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n ratio_factor = 1 / (rest_capacities / item)\\n \\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= ratio_factor / (np.arange(1, len(bins) + 1) ** 3)\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, penalties for bins at maximum capacity, the proximity to the item size, and a new factor that takes into account the number of items already assigned to the bin and a penalty for bins with higher indices.\\n\\nHere is the implementation code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n num_bins = len(bins)\\n min_capacity = np.min(rest_capacities)\\n indices = np.arange(1, num_bins + 1)\\n\\n scores = ((rest_capacities - min_capacity) / indices) - np.log(np.square(rest_capacities))\\n scores += np.square(1 / (rest_capacities + 1)) / indices\\n scores -= np.sqrt(rest_capacities) / indices\\n scores += np.square(rest_capacities) / np.arange(num_bins, 0, -1)\\n scores -= np.sqrt(np.abs(rest_capacities - item)) / (indices ** 2)\\n scores -= (num_bins - indices) / (np.arange(num_bins, 0, -1) ** 2)\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and introduces a new factor that considers the ratio of the remaining capacity to the item size, while also prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n size_ratio = (bins - item) / item\\n indices = np.arange(len(bins), 0, -1)\\n \\n scores = ((bins - item) / indices) - np.log(np.square(bins - item))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (indices + 1))\\n scores += np.square(bins - item) / indices\\n scores -= np.log(size_ratio)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the ratio of remaining capacity to the item size, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity, while also considering the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n ratio_penalty = (rest_capacities / item)\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= ratio_penalty / (np.arange(1, len(bins) + 1) ** 3)\\n scores -= np.power(np.max(bins) - rest_capacities, 2) / np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm calculates the scores for each bin based on the remaining capacity, penalties for bins at maximum capacity, and introduces a new factor that considers the ratio of the remaining capacity to the item size, while also prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n max_capacity = np.max(rest_capacities)\\n indices = np.arange(len(bins), 0, -1)\\n scores = ((rest_capacities - max_capacity) / indices) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores += np.square(rest_capacities) / indices\\n scores -= np.log(rest_capacities / item)\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, the square of the remaining capacity, and a factor that promotes bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n proximity = np.abs(remaining_capacities - item)\\n scores = ((remaining_capacities - np.min(remaining_capacities)) / np.arange(1, len(bins) + 1)) - np.log(remaining_capacities ** 2)\\n scores += np.square(remaining_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / (np.arange(1, len(bins) + 1) ** 2)\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and introduces a new factor that considers the ratio of the remaining capacity to the item size, while also prioritizing bins with higher remaining capacity and penalizing bins with lower indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n size_ratio = (bins - item) / item\\n indices = np.arange(len(bins), 0, -1)\\n\\n scores = ((bins - item) / indices) - np.log(np.square(bins - item))\\n scores[1:] -= np.diff(bins)\\n scores -= np.square(1 / (indices + 1))\\n scores += np.square(bins - item) / indices\\n scores -= np.log(size_ratio)\\n\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, avoiding their usage, and a new factor that encourages bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower index.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] -= np.abs(np.diff(bins))\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n # Add a new factor to prioritize higher remaining capacity bins and penalize lower index bins\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, a factor that promotes bin utilization by prioritizing bins with higher remaining capacity and penalizing bins with lower indices, and a factor that considers the ratio of the remaining capacity to the item size. It also incorporates a modified version of the existing algorithm to further optimize performance.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n proximity = np.abs(remaining_capacities - item)\\n scores = ((remaining_capacities - np.min(remaining_capacities)) / np.arange(1, len(bins) + 1)) - np.log(remaining_capacities ** 2)\\n scores += np.square(remaining_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / (np.arange(1, len(bins) + 1) ** 2)\\n scores += remaining_capacities / item\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 2))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, and penalties for bins at maximum capacity and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, a factor that encourages bin utilization by prioritizing bins with lower indices first, and a new factor that promotes bin utilization by prioritizing bins with higher remaining capacity.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n proximity = np.abs(rest_capacities - item)\\n diff_capacities = np.diff(bins)\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores[1:] += np.flip(diff_capacities)\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) +1))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n scores += np.exp(-proximity) / (np.arange(len(bins), 0, -1) ** 2)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and factors that encourage bin utilization by prioritizing bins with higher remaining capacity or lower indices.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the square of the remaining capacity, penalties for bins at maximum capacity, a factor that promotes bin utilization by prioritizing bins with higher remaining capacity, and a factor that promotes bin utilization by prioritizing bins with lower indices first.\\n\\nNew algorithm implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n proximity = np.abs(remaining_capacities - item)\\n scores = ((remaining_capacities - np.min(remaining_capacities)) / np.arange(1, len(bins) + 1)) - np.log(remaining_capacities ** 2)\\n scores += np.square(remaining_capacities) / np.arange(len(bins), 0, -1)\\n scores -= np.sqrt(proximity) / (np.arange(1, len(bins) + 1) ** 2)\\n scores -= np.square(1 / (np.arange(len(bins), 0, -1) + 1))\\n scores -= np.log(np.square(remaining_capacities))\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate scores for each bin based on the remaining capacity, the proximity to the item size, penalties for bins at maximum capacity, and avoiding their usage.\\n\\nNew algorithm description: The new algorithm calculates scores for each bin based on the remaining capacity, penalties for bins at maximum capacity, and a new factor that encourages bin utilization by penalizing bins with high remaining capacity and lower indices first, while also considering the average proximity to the item size and the difference between the maximum and minimum capacities.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n\\n scores = ((rest_capacities - np.max(rest_capacities)) / np.arange(len(bins), 0, -1)) - np.log(np.square(rest_capacities))\\n scores += np.square(rest_capacities) / np.arange(len(bins), 0, -1)\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on the remaining capacity, the proximity to the item size, the difference between the capacities of adjacent bins, the logarithm of the remaining capacity squared, and a new factor that encourages bin utilization by prioritizing bins with lower indices first and penalizing bins with high remaining capacity, while also considering the ratios of the remaining capacity to the item size. \\n\\nNew algorithm implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = ((rest_capacities - np.min(rest_capacities)) / np.arange(1, len(bins) + 1)) - np.log(np.square(rest_capacities))\\n scores -= np.sqrt(rest_capacities) / (np.arange(1, len(bins) + 1) ** 2)\\n ratios = (rest_capacities / item)\\n scores -= ratios / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size to the remaining capacity, and the square of the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher inverse values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n inverse_capacity = 1 / remaining_capacity\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + inverse_capacity\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = item / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the item size divided by the remaining capacity, raised to the power of 0.8, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity + (logarithm ** 0.8)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function assigns items to bins based on the maximum score, while avoiding using bins at maximum capacity in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == np.max(bins)] = -1\\n scores = remaining_capacity / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with more remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, bins - item) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will assign a score to each bin based on the remaining capacity after placing the item. The score will be calculated by taking the reciprocal of the difference between the bin capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity. Higher scores indicate better candidates for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.15595,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm calculates the score for each bin based on the rest capacity and assigns the item to the bin with the maximum score, aiming to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = np.maximum(0, max_capacity - bins) # Calculate rest capacity\\n mask = rest_capacity < item # Check if rest capacity is enough for the item\\n rest_capacity[mask] = 0 # Set rest capacity to 0 if it's not enough\\n scores = rest_capacity / (max_capacity * (1 - mask)) # Calculate scores for each bin\\n return scores\",\n \"objective\": 0.31975,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the score for each bin by taking the ratio of the rest capacity to the item size, and then subtracting 1 if the rest capacity equals the maximum capacity, in order to prioritize the bin with the largest available space but not the maximum capacity, with the main steps being to calculate the scores and return them as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm as follows:\\nThe algorithm will calculate the score for each bin based on the remaining capacity after assigning the item, with a penalty for bins at maximum capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) - (bins == bins.max()) * (item + 1)\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the remaining capacity of each bin after assigning the item, and then assigns a score to each bin based on the ratio of remaining capacity to the maximum capacity, with a penalty for bins with maximum capacity. It then returns the scores for all bins using Numpy array. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_ratio = remaining_capacity / np.max(bins)\\n remaining_ratio[bins == np.max(bins)] -= 0.5 # Apply penalty for bins with maximum capacity\\n scores = remaining_ratio\\n return scores\",\n \"objective\": 0.40739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves ranking the bins based on their remaining capacity after assigning the item, and penalizing bins with maximum capacity to discourage their use. First, calculate the remaining capacity of each bin after assigning the item, then calculate the score for each bin by considering its remaining capacity and penalizing bins with maximum capacity. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalized_capacity = np.where(remaining_capacity < np.max(remaining_capacity), remaining_capacity, np.max(remaining_capacity) * 2)\\n scores = penalized_capacity * (1 + np.log(1 + np.abs(penalized_capacity - np.max(penalized_capacity))))\\n return scores\",\n \"objective\": 0.5735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the minimum between the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.maximum(bins - item, 0)\\n scores = np.minimum(capacities, item)\\n return scores\",\n \"objective\": 0.64021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: First, calculate the free space in each bin after adding the item, then compute the score for each bin using a novel formula that takes into account the free space and the distance from the maximum capacity, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_space = bins - item\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - remaining_space\\n scores = remaining_space * (1 + distance_from_max)\\n return scores\",\n \"objective\": 0.77412,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the following formula: score = (bin_capacity - item_size) * (1 - bin_index/N), where N is the total number of bins. Then, the function will return the scores for each bin in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n scores = (bins - item) * (1 - np.arange(N)/N)\\n return scores\",\n \"objective\": 0.89174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacity of each bin after adding the item, and then scores each bin based on the formula: ((maximum capacity - available capacity) / maximum capacity) * available capacity, where bins with the maximum capacity are not scored. Finally, the function returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n available_capacity = np.maximum(0, (bins + item) - max_capacity)\\n scores = ((max_capacity - available_capacity) / max_capacity) * available_capacity\\n scores[available_capacity == 0] = 0\\n return scores\",\n \"objective\": 1.21401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplementing the algorithm:\\n1. Create a function named score that accepts two input parameters: 'item' and 'bins'.\\n2. Inside the function, calculate the scores for each bin by first finding the difference between the maximum capacity of each bin and the size of the item.\\n3. For bins that have a rest capacity equal to the maximum capacity, assign a score of -1 to make them ineligible for item assignment.\\n4. Return the calculated scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == bins.max()).astype(int) * -1\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm: The algorithm first calculates the scores for each bin based on the rest capacity and the current item size, then it returns the scores for the bins for assignment.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0)\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and additionally, it will prioritize bins that have a capacity closest to the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - diff\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the difference between the item size and bin capacity, and the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller differences between item size and bin capacity, and smaller inverse bin indices. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.log(np.abs(diff))\\n \\n # Penalize bins that have been used already\\n scores *= (bins != max_capacity)\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, their index in the bin list, and a penalty based on the difference between bin capacity and item size, prioritizing bins with larger remaining capacities, smaller indices, capacity closer to the item size, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n penalty = 1 / (1 + np.abs(diff - max_capacity))\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) + penalty - np.log(np.abs(diff))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.max(bins) - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, their index in the bin list, and a penalty based on the difference between bin capacity and item size. It prioritizes bins with larger remaining capacities, smaller indices, capacity closer to the item size, and smaller penalty values. Additionally, the scores are modified to prioritize bins that have not been used yet over bins that have been used previously, while ensuring not to use bins with maximum capacity.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n penalty = 1 / (1 + np.abs(diff - max_capacity))\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) + penalty - np.log(np.abs(diff))\\n \\n # Penalize bins that have been used already\\n scores *= (bins != max_capacity)\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. Additionally, the scores are modified to prioritize both bins with larger remaining capacities and bins that have not been used yet over bins with smaller remaining capacities or bins that have been used.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on remaining capacity\\n scores = (bins / (max_capacity - bins + 1)) * (1 / np.arange(1, n + 1))\\n \\n # Penalize bins that have been used already\\n scores *= (bins != max_capacity)\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. Additionally, the scores are modified to prioritize bins with smaller remaining capacities over bins with larger remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins + np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the scores for each bin based on their remaining capacity and a penalty term based on the bin index, while ensuring not to use bins with maximum capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, and the bin index, while ensuring not to use bins with maximum capacity. The scores are modified to prioritize bins with larger remaining capacities and smaller indices, in addition to penalizing bins that are close to the item size, using a complex formula.\\n\\nImplementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n num_bins = len(bins)\\n \\n proximity_penalty = np.abs(bins - item)\\n remaining_capacity_bonus = (max_capacity - bins) / (1 + np.arange(num_bins))\\n bin_index_penalty = 1 / (1 + np.arange(num_bins))\\n \\n scores = remaining_capacity_bonus - proximity_penalty**2 + np.exp(bin_index_penalty)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. Additionally, the scores are modified to prioritize bins with smaller remaining capacities over bins with larger remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. Additionally, the scores are modified to prioritize bins with larger remaining capacities over bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, and the bin index, while ensuring not to use bins with maximum capacity. The scores are modified to prioritize bins with larger remaining capacities and smaller indices, in addition to penalizing bins that are close to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n num_bins = len(bins)\\n \\n proximity_penalty = np.abs(bins - item)\\n remaining_capacity_bonus = (max_capacity - bins) / (1 + np.arange(num_bins))\\n bin_index_penalty = 1 / (1 + np.arange(num_bins))\\n \\n scores = remaining_capacity_bonus - proximity_penalty - bin_index_penalty\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04296,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, a penalty term that increases exponentially with the bin index, and a term that prioritizes bins closer to the item size by penalizing large differences.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins = len(bins)\\n \\n remaining_capacity = max_capacity - bins\\n bin_index_penalty = np.exp(np.arange(num_bins))\\n difference_penalty = np.exp(-np.abs(bins - item))\\n \\n scores = remaining_capacity * difference_penalty * bin_index_penalty\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, a logarithmic penalty term that decreases with the bin index, and a term that prioritizes bins closer to the item size by penalizing large differences.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins = len(bins)\\n \\n remaining_capacity = max_capacity - bins\\n bin_index_penalty = np.log(np.arange(1, num_bins+1))\\n difference_penalty = np.exp(-np.abs(bins - item))\\n \\n scores = remaining_capacity * difference_penalty * bin_index_penalty\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, the square root of their proximity to the item size, and a penalty based on the bin index, prioritizing bins with larger remaining capacities and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) - np.arange(len(bins))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. The scores are calculated using a formula that takes into account the square root of the remaining capacity of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins - item + 1) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, and a penalty based on the bin index, prioritizing bins with larger remaining capacities and smaller indices.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04538,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, their index in the bin list, and a penalty based on the difference between bin capacity and item size, prioritizing bins with larger remaining capacities, smaller indices, and capacity closer to the item size.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n penalty = 1 / (1 + np.abs(diff - max_capacity))\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) + penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04598,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and their index, assigning a penalty for bins with larger indices, then assigns the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins))) - np.log(1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, assigning a penalty for bins with smaller remaining capacity, and a bonus for bins with larger index; then assigns the item to the bin with the maximum score, while ensuring not to use bins with the maximum capacity.\\n\\nHere is the implementation of the new score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n max_capacity = bins.max()\\n \\n scores = (max_capacity - bins + item) / (1 + np.arange(num_bins)) + np.arange(num_bins)\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.04658,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity + item) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher sum values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n sum_scores = (remaining_capacity % item) * np.log(remaining_capacity) + np.sqrt(item / remaining_capacity) + np.exp(item * remaining_capacity)\\n \\n scores = sum_scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n remaining_capacity_normalized = remaining_capacity / max_capacity\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity_normalized)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, the logarithm of the inverse of the bin index, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller squared differences, smaller logarithmic inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_squared = np.square(bins - item)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(diff_squared)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, and the logarithm of the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller squared differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_squared = np.square(bins - item)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n \\n scores = (bins - item) - np.log(np.abs(diff_squared)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the utilization ratio (remaining capacity divided by the bin's original capacity), the difference between the item size and bin capacity, and the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, lower utilization ratios, smaller differences between item size and bin capacity, and smaller bin indices. The scores are returned as a Numpy array.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n utilization_ratio = remaining_capacity / bins\\n diff = np.abs(bins - item)\\n bin_index = np.arange(len(bins))\\n scores = remaining_capacity - np.log(np.abs(diff)) - utilization_ratio - bin_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and additionally, it will prioritize bins that have a larger remaining capacity than the item size. The new algorithm will assign higher scores to bins with larger remaining capacity by implementing a weighted penalty for the difference between the capacity of the bin and the item size, and will give lower scores to bins with maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - np.maximum(diff, 0) * (item / (1.0 + diff))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm aims to assign the item to the bin that has the closest capacity to the item size, while still considering the remaining capacity and inverse bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n inverse_index = 1 / np.arange(1, len(bins) + 1)\\n \\n scores = (bins - item) - np.log(np.abs(diff)) - inverse_index\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, and the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller squared differences between item size and bin capacity, and smaller inverse bin indices. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_squared = np.square(bins - item)\\n scores = (bins - item) - np.log(np.abs(diff_squared))\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the square root of their proximity to the item size, and a penalty based on the bin index, prioritizing bins with larger remaining capacities and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * np.sqrt((1 / (1 + np.arange(len(bins))))) - np.log(np.abs(bins - item)) - np.arange(len(bins))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the difference between the item size and bin capacity, and the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller differences between item size and bin capacity, and smaller inverse bin indices. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n scores = (bins - item) - np.log(np.abs(diff))\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and additionally, it will prioritize bins that have a capacity closest to the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - diff\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the difference between the item size and bin capacity, and the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller differences between item size and bin capacity, and smaller inverse bin indices. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.log(np.abs(diff))\\n \\n # Penalize bins that have been used already\\n scores *= (bins != max_capacity)\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"implement your new algorithm in the score function as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.sum(bins) # Simplified calculation of 'max_capacity'\\n diff = np.abs(bins - item)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - diff + np.random.randn(len(bins))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, their index in the bin list, and a penalty based on the difference between bin capacity and item size, prioritizing bins with larger remaining capacities, smaller indices, capacity closer to the item size, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) - np.log(np.abs(bins - item))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, their index in the bin list, and a penalty based on the difference between bin capacity and item size, prioritizing bins with larger remaining capacities, smaller indices, capacity closer to the item size, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n penalty = 1 / (1 + np.abs(diff - max_capacity))\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) + penalty - np.log(np.abs(diff))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.max(bins) - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"implement your new algorithm in the score function as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - diff + np.random.randn(len(bins))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, their proximity to the item size, their index in the bin list, and a penalty based on the difference between bin capacity and item size. It prioritizes bins with larger remaining capacities, smaller indices, capacity closer to the item size, and smaller penalty values. Additionally, the scores are modified to prioritize bins that have not been used yet over bins that have been used previously, while ensuring not to use bins with maximum capacity.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n penalty = 1 / (1 + np.abs(diff - max_capacity))\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) + penalty - np.log(np.abs(diff))\\n \\n # Penalize bins that have been used already\\n scores *= (bins != max_capacity)\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. Additionally, the scores are modified to prioritize bins with larger remaining capacities and bins that have not been used yet over bins with smaller remaining capacities or bins that have been used.\\n\\n\",\n \"code\": \"def score(item, bins):\\n n = len(bins)\\n max_capacity = np.max(bins)\\n \\n # Calculate the scores based on remaining capacity\\n scores = (bins / (max_capacity - bins + 1)) * (1 / np.arange(1, n + 1))\\n \\n # Penalize bins that have been used already\\n scores *= (bins != max_capacity)\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the logarithm of their proximity to the item size, and a penalty based on the bin index, prioritizing bins with larger remaining capacities and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * (1 / (1 + np.arange(len(bins)))) - np.log(np.abs(bins - item)) - np.arange(len(bins))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the scores for each bin based on their remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on their remaining capacity, the proximity of the bin capacity to the item size, and the index of the bin in the bin list, while ensuring not to use bins with maximum capacity. The scores are modified to prioritize bins with larger remaining capacities, smaller indices, and capacities closer to the item size, by incorporating these factors in a complex formula.\\n\\nImplementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = np.abs(bins - item)\\n penalty = 1 / (1 + np.abs(diff - max_capacity))\\n scores = bins * (1 / (1 + np.arange(len(bins)))) - np.sqrt(np.abs(bins - item)) + penalty - np.log(np.abs(diff))\\n \\n # Penalize bins that have been used already\\n scores *= (bins != max_capacity)\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. Additionally, the scores are modified to prioritize bins with smaller remaining capacities over bins with larger remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins + np.arange(len(bins)) + 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the harmonic mean of the item size and the remaining capacity, the square root of the logarithm of the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n harmonic_mean = 2 / (1/item + 1/remaining_capacity)\\n sqrt_log_capacity = np.sqrt(np.log(remaining_capacity))\\n \\n scores = harmonic_mean * sqrt_log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the factor of the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 4, the inverse of the bin index raised to the power of 2, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 4\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 2\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the difference between the item size and bin capacity raised to the power of 4, and the exponential function of the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller quartic differences between item size and bin capacity, and smaller exponential inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n inverse_index = np.exp(1 / np.arange(1, len(bins) + 1))\\n\\n scores = diff - np.log(np.abs(np.power(diff, 4))) - inverse_index\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 3, the inverse of the bin index raised to the power of 4, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 3\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 4\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 3, the reciprocal of the bin index raised to the power of 2, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 3\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 2\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the product of the difference and inverse of the item size and bin capacity, and the logarithm of the squared inverse bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_inverse_product = (bins - item) * (1 / (item * bins))\\n squared_inverse_index = np.square(1 / np.log(np.arange(1, len(bins) + 1)))\\n \\n scores = (bins - item) - np.log(np.abs(diff_inverse_product)) - squared_inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the difference between the item size and bin capacity, the natural logarithm of the inverse of the bin index, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller square root differences, smaller logarithmic inverse bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n sqrt_diff = np.sqrt(np.abs(bins - item))\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(sqrt_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube of the difference between the item size and bin capacity, and the natural logarithm of the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller cubed differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n \\n scores = diff - np.log(np.abs(diff)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 5, the reciprocal of the bin index raised to the power of 3, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.sqrt(np.abs(bins - item) ** 5)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 3\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, the logarithm of the inverse of the bin index, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller squared differences, smaller logarithmic inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_squared = np.square(bins - item)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(diff_squared)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, and the logarithm of the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller squared differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_squared = np.square(bins - item)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n \\n scores = (bins - item) - np.log(np.abs(diff_squared)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02867,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, the logarithm of the inverse of the bin index, the utilization ratio (remaining capacity divided by the bin's original capacity), and a penalty based on the difference between the maximum capacity and the bin capacity. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller squared differences, smaller logarithmic inverse bin indices, lower utilization ratios, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n diff_squared = np.square(bins - item)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n utilization_ratio = remaining_capacity / bins\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = remaining_capacity - np.log(np.abs(diff_squared)) - inverse_index - utilization_ratio + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 4, and the inverse of the bin index raised to the power of 2, penalizing bins at maximum capacity and prioritizing bins with larger remaining capacities, smaller absolute differences, and smaller inverse bin indices, but in a different manner than previous algorithms.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 4\\n inverse_index = 1 / np.arange(1, len(bins) + 1) ** 2\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, and the logarithm of the bin capacity. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller squared differences between item size and bin capacity, and smaller logarithmic bin capacities.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_squared = np.square(bins - item)\\n log_capacity = np.log(bins)\\n \\n scores = (bins - item) - np.log(np.abs(diff_squared)) - log_capacity\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the natural logarithm of the inverse of the bin index raised to the power of 2, and the logarithm of the difference between the item size and bin capacity raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller quadratic inverse bin indices, and smaller cubic differences between item size and bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 2\\n diff = bins - item\\n\\n scores = diff - np.log(np.abs(np.power(diff, 3))) - inverse_index\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the square root of their proximity to the item size, and a penalty based on the bin index, prioritizing bins with larger remaining capacities and smaller indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * 0.5 - np.log(np.abs(bins - item)) - np.arange(len(bins))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube of the difference between the item size and bin capacity, and the reciprocal of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller cubed differences between item size and bin capacity, and smaller reciprocal bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_cubed = np.power(bins - item, 3)\\n reciprocal_index = 1 / np.arange(1, len(bins) + 1)\\n \\n scores = (bins - item) - np.log(np.abs(diff_cubed)) - reciprocal_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the utilization ratio (remaining capacity divided by the bin's original capacity), the difference between the item size and bin capacity, and the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, lower utilization ratios, smaller differences between item size and bin capacity, and smaller bin indices. The scores are returned as a Numpy array.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n utilization_ratio = remaining_capacity / bins\\n diff = np.abs(bins - item)\\n bin_index = np.arange(len(bins))\\n scores = remaining_capacity - np.log(np.abs(diff)) - utilization_ratio - bin_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and additionally, it will prioritize bins that have a larger remaining capacity than the item size. The new algorithm will assign higher scores to bins with larger remaining capacity by implementing a weighted penalty for the difference between the capacity of the bin and the item size, and will give lower scores to bins with maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - np.maximum(diff, 0) * (item / (1.0 + diff))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the inverse of the bin index raised to the power of 3, and the logarithm of the difference between the item size and bin capacity. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller cubic differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_cubic = np.power(bins - item, 3)\\n inverse_index = np.power(1 / np.arange(1, len(bins) + 1), 3)\\n \\n scores = (bins - item) - np.log(np.abs(diff_cubic)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is as follows: The score for each bin is calculated based on the remaining capacity, the natural logarithm of the inverse of the bin index raised to the power of 3, and the logarithm of the square of the difference between the item size and bin capacity. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller cubic inverse bin indices, and smaller logarithmic differences between item size and bin capacity.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 3\\n diff = bins - item\\n\\n scores = diff - np.log(np.power(diff, 2)) - inverse_index\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 6, and the logarithmic function of the inverse of the bin index raised to the power of 4. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller sixth power differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_sixth_power = np.power(np.abs(bins - item), 6)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 4\\n \\n scores = (bins - item) - np.log(np.abs(diff_sixth_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 6\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 4\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n abs_diff = np.abs(bins - item) ** 6\\n penalty = 1\\n \\n scores = (bins - item) - np.log(abs_diff) + penalty\\n \\n scores[(bins == np.max(bins))] = 0\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the reciprocal of the bin index raised to the power of 3, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller reciprocal bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n reciprocal_index = 1 / np.arange(1, len(bins) + 1) ** 3\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - reciprocal_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 5, the reciprocal of the bin index raised to the power of 3, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n scaling_factor = 10 / len(bins) # Adjust the scaling factor to control the range of the index\\n \\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - scaling_factor * np.arange(1, len(bins) + 1) + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 4, the inverse of the bin index raised to the power of 2, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 4\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 2\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the difference between the item size and bin capacity raised to the power of 4, and the exponential function of the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller quartic differences between item size and bin capacity, and smaller exponential inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n inverse_index = np.exp(1 / np.arange(1, len(bins) + 1))\\n\\n scores = diff - np.log(np.abs(np.power(diff, 4))) - inverse_index\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 3, the inverse of the bin index raised to the power of 4, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 3\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 4\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, and the logarithmic function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_fifth_power = np.power(np.abs(bins - item), 5)\\n inverse_index_cubed = np.log(1 / np.arange(1, len(bins) + 1)) ** 3\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff_fifth_power)) - inverse_index_cubed\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the square root of the remaining capacity, the logarithm of the product of the absolute difference between the item size and bin capacity and the inverse of the bin index, and a penalty based on the difference between the maximum capacity and the bin capacity. It prioritizes bins with larger remaining capacities, smaller absolute differences multiplied by inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n abs_diff_inverse_index = np.log(np.abs(bins - item) * (1 / np.log(np.arange(1, len(bins) + 1))))\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = sqrt_remaining_capacity - abs_diff_inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02556,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the cube of the difference between the item size and bin capacity, the logarithm of the inverse of the bin index, and a penalty value proportional to the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller cubed differences, smaller logarithmic inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_cubed = np.power(bins - item, 3)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n penalty = (max_capacity - bins) / max_capacity\\n \\n scores = (bins - item) - np.log(np.abs(diff_cubed)) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 3, the reciprocal of the bin index raised to the power of 2, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 3\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 2\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02686,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the product of the difference and inverse of the item size and bin capacity, the logarithm of the squared inverse bin index, and the exponential function of the inverse bin index divided by the difference between the item size and bin capacity. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller differences between item size and bin capacity, smaller logarithmic inverse bin indices, and smaller exponential inverse bin indices divided by the difference between the item size and bin capacity.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_inverse_product = (bins - item) * (1 / (item * bins))\\n squared_inverse_index = np.square(1 / np.log(np.arange(1, len(bins) + 1)))\\n exponential_inverse_index = np.exp(-1 / np.abs(bins - item))\\n \\n scores = (bins - item) - np.log(np.abs(diff_inverse_product)) - squared_inverse_index - exponential_inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the product of the difference and inverse of the item size and bin capacity, and the logarithm of the squared inverse bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_inverse_product = (bins - item) * (1 / (item * bins))\\n squared_inverse_index = np.square(1 / np.log(np.arange(1, len(bins) + 1)))\\n \\n scores = (bins - item) - np.log(np.abs(diff_inverse_product)) - squared_inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 3, the product of the inverse bin index and the utilization ratio, and a penalty based on the difference between the maximum capacity and the bin capacity. It prioritizes bins with larger remaining capacities, smaller logarithmic absolute differences, smaller inverse bin indices multiplied by utilization ratios, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n abs_diff_log = np.log(np.abs(bins - item) ** 3)\\n inverse_index_utilization = (1 / np.log(np.arange(1, len(bins) + 1))) * (remaining_capacity / bins)\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = remaining_capacity - abs_diff_log - inverse_index_utilization + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02727,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the difference between the item size and bin capacity, the natural logarithm of the inverse of the bin index, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller square root differences, smaller logarithmic inverse bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n sqrt_diff = np.sqrt(np.abs(bins - item))\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(sqrt_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02777,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the product of the difference and inverse of the item size and bin capacity, the logarithm of the squared inverse bin index, and the exponential function of the inverse bin index divided by the difference between the item size and bin capacity. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller differences between item size and bin capacity, smaller logarithmic inverse bin indices, and smaller exponential inverse bin indices divided by the difference between the item size and bin capacity.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = (bins - item)\\n squared_inverse_index = np.square(1 / np.log(np.arange(1, len(bins) + 1)))\\n \\n scores = diff - np.log(np.abs(diff)) - squared_inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube of the difference between the item size and bin capacity, and the natural logarithm of the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller cubed differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n \\n scores = diff - np.log(np.abs(diff)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02797,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 5, the reciprocal of the bin index raised to the power of 3, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.sqrt(np.abs(bins - item) ** 5)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 3\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square of the difference between the item size and bin capacity, the logarithm of the inverse of the bin index, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller squared differences, smaller logarithmic inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_squared = np.square(bins - item)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1))\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(diff_squared)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02857,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 6, and the logarithmic function of the inverse of the bin index raised to the power of 4. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller sixth power differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_sixth_power = np.power(np.abs(bins - item), 6)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 4\\n \\n scores = (bins - item) - np.log(np.abs(diff_sixth_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 6\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 4\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the absolute difference between the item size and bin capacity raised to the power of 7, and the exponential function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between item size and bin capacity, and smaller exponential inverse bin indices.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = np.exp(-1 / np.log(np.arange(1, len(bins) + 1))) ** 3\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 9, the exponential of the inverse of the bin index raised to the power of 6, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller ninth power differences, larger inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.sqrt(np.abs(bins - item)) ** 9\\n inverse_index = np.exp(1 / np.arange(1, len(bins) + 1)) ** 6\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 5, and the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and smaller bin indices.\\n\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_fifth_power = np.power(np.abs(bins - item), 5)\\n bin_index_power = np.power(np.arange(1, len(bins) + 1), 3)\\n \\n scores = (bins - item) - np.log(np.abs(diff_fifth_power)) - bin_index_power\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n abs_diff = np.abs(bins - item) ** 6\\n penalty = 1\\n \\n scores = (bins - item) - np.log(abs_diff) + penalty\\n \\n scores[(bins == np.max(bins))] = 0\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the inverse of the bin index raised to the power of 3, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 3\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity, penalize bins at maximum capacity, and prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the absolute difference between the item size and bin capacity raised to the power of 7, and the inverse of the bin index raised to the power of 5. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between item size and bin capacity, and smaller inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 5\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between the item size and bin capacity.\\n\\nThe new algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 7, the reciprocal of the logarithm of the bin index raised to the power of 5, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.log(np.abs(bins - item)) ** 7\\n log_inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 5\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - log_inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the reciprocal of the bin index raised to the power of 3, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller reciprocal bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n reciprocal_index = 1 / np.arange(1, len(bins) + 1) ** 3\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - reciprocal_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 4, the bin index raised to the power of 2, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 4\\n bin_index = np.arange(1, len(bins) + 1) ** 2\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - bin_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 5, the reciprocal of the bin index raised to the power of 3, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n scaling_factor = 10 / len(bins) # Adjust the scaling factor to control the range of the index\\n \\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - scaling_factor * np.arange(1, len(bins) + 1) + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the inverse of the bin index raised to the power of 3, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, larger penalties for exceeding the maximum capacity, smaller absolute differences, and smaller inverse bin indices.\\n\\nPython Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n inverse_index = 1 / np.arange(1, len(bins) + 1) ** 3\\n penalty = (max_capacity - bins) / max_capacity\\n \\n scores = bins - item - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the common backbone idea of the provided algorithms, the new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 3, the exponential function of the inverse of the bin index raised to the power of 5, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, larger exponential inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 3\\n inverse_index = np.exp(1 / np.log(np.arange(1, len(bins) + 1)) ** 5)\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n\\n return scores\",\n \"objective\": 0.02264,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate the scores for each bin based on the remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 4, the inverse of the bin index raised to the power of 2, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 4\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 2\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02274,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square of the absolute difference between the item size and bin capacity, the exponential function of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the square root of the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, larger exponential inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_squared = np.square(np.abs(bins - item))\\n inverse_index = np.exp(1 / np.log(np.arange(1, len(bins) + 1)) ** 4)\\n penalty = np.sqrt(1 / (max_capacity - bins + 1))\\n \\n scores = (bins - item) - np.log(abs_diff_squared) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02314,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the difference between the item size and bin capacity raised to the power of 4, and the exponential function of the inverse of the bin index. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller quartic differences between item size and bin capacity, and smaller exponential inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff = bins - item\\n inverse_index = np.exp(1 / np.arange(1, len(bins) + 1))\\n\\n scores = diff - np.log(np.abs(np.power(diff, 4))) - inverse_index\\n\\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the log of the absolute difference between the item size and bin capacity raised to the power of 3, and the reciprocal of the bin index raised to the power of 4. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller third power differences between item size and bin capacity, and smaller reciprocal bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_third_power = np.power(np.abs(bins - item), 3)\\n reciprocal_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 4\\n \\n scores = (bins - item) - np.log(np.abs(diff_third_power)) - reciprocal_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, and the logarithmic function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_fifth_power = np.power(np.abs(bins - item), 5)\\n inverse_index_cubed = np.log(1 / np.arange(1, len(bins) + 1)) ** 3\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff_fifth_power)) - inverse_index_cubed\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their remaining capacity and certain additional factors.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the square root of the remaining capacity, the logarithm of the product of the absolute difference between the item size and bin capacity and the inverse of the bin index, and a penalty based on the difference between the maximum capacity and the bin capacity. It prioritizes bins with larger remaining capacities, smaller absolute differences multiplied by inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_remaining_capacity = np.sqrt(remaining_capacity)\\n abs_diff_inverse_index = np.log(np.abs(bins - item) * (1 / np.log(np.arange(1, len(bins) + 1))))\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = sqrt_remaining_capacity - abs_diff_inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02556,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the logarithm of the bin index raised to the power of 2, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nNew Python code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n index = np.log(np.arange(1, len(bins) + 1)) ** 2\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity, penalize bins at maximum capacity, and prioritize bins with larger remaining capacities and smaller differences between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithmic function of the absolute difference between the item size and bin capacity raised to the power of 5, and the exponential function of the inverse of the bin index raised to the power of 2. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and larger exponential inverse bin indices.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_fifth_power = np.power(np.abs(bins - item), 5)\\n inverse_index_squared = np.exp(1 / np.log(np.arange(1, len(bins) + 1))) ** 2\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff_fifth_power)) - inverse_index_squared\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 6, and the logarithmic function of the inverse of the bin index raised to the power of 4. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller sixth power differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_sixth_power = np.power(np.abs(bins - item), 6)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 4\\n \\n scores = (bins - item) - np.log(np.abs(diff_sixth_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 6\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 4\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the absolute difference between the item size and bin capacity raised to the power of 7, and the exponential function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between item size and bin capacity, and smaller exponential inverse bin indices.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = np.exp(-1 / np.log(np.arange(1, len(bins) + 1))) ** 3\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 9, the exponential of the inverse of the bin index raised to the power of 6, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller ninth power differences, larger inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.sqrt(np.abs(bins - item)) ** 9\\n inverse_index = np.exp(1 / np.arange(1, len(bins) + 1)) ** 6\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 7, and the logarithmic function of the inverse of the bin index raised to the power of 5. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between the item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 5\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 7, the logarithmic function of the inverse of the bin index raised to the power of 5, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller logarithmic inverse bin indices, and smaller penalty values.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 7\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 5\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 5, and the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and smaller bin indices.\\n\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_fifth_power = np.power(np.abs(bins - item), 5)\\n bin_index_power = np.power(np.arange(1, len(bins) + 1), 3)\\n \\n scores = (bins - item) - np.log(np.abs(diff_fifth_power)) - bin_index_power\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n abs_diff = np.abs(bins - item) ** 6\\n penalty = 1\\n \\n scores = (bins - item) - np.log(abs_diff) + penalty\\n \\n scores[(bins == np.max(bins))] = 0\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the inverse of the bin index raised to the power of 3, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 3\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity, penalize bins at maximum capacity, and prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the absolute difference between the item size and bin capacity raised to the power of 7, and the inverse of the bin index raised to the power of 5. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between item size and bin capacity, and smaller inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 5\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the natural logarithm of the absolute difference between the item size and bin capacity raised to the power of 6, the square root of the bin index raised to the power of 4, and the exponential function of the inverse of the item size raised to the power of 2. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller sixth power differences between item size and bin capacity, larger square root bin indices, and smaller exponential inverse item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_sixth_power = np.power(np.abs(bins - item), 6)\\n sqrt_bin_index_power = np.power(np.sqrt(np.arange(1, len(bins) + 1)), 4)\\n inverse_item_size_power = np.exp(-1 / np.log(item)) ** 2\\n \\n scores = (bins - item) - np.log(np.abs(diff_sixth_power)) - sqrt_bin_index_power + inverse_item_size_power\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between the item size and bin capacity.\\n\\nThe new algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 7, the reciprocal of the logarithm of the bin index raised to the power of 5, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.log(np.abs(bins - item)) ** 7\\n log_inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 5\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - log_inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the inverse of the bin index raised to the power of 4, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n inverse_index = 1 / np.arange(1, len(bins) + 1) ** 4\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 10, the inverse of the bin index raised to the power of 8, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller tenth power differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_tenth_power = np.sqrt(np.abs(bins - item)) ** 10\\n inverse_index = 1 / np.arange(1, len(bins) + 1) ** 8\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(diff_tenth_power) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 4, the bin index raised to the power of 2, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 4\\n bin_index = np.arange(1, len(bins) + 1) ** 2\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - bin_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 5, the reciprocal of the bin index raised to the power of 3, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n scaling_factor = 10 / len(bins) # Adjust the scaling factor to control the range of the index\\n \\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - scaling_factor * np.arange(1, len(bins) + 1) + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the inverse of the bin index raised to the power of 3, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, larger penalties for exceeding the maximum capacity, smaller absolute differences, and smaller inverse bin indices.\\n\\nPython Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n inverse_index = 1 / np.arange(1, len(bins) + 1) ** 3\\n penalty = (max_capacity - bins) / max_capacity\\n \\n scores = bins - item - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square of the absolute difference between the item size and bin capacity, the exponential function of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the square root of the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, larger exponential inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item)\\n inverse_index = np.exp(1 / np.log(np.arange(1, len(bins) + 1)) ** 4)\\n penalty = np.sqrt(1 / (max_capacity - bins + 1))\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the logarithm of the bin index raised to the power of 2, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nNew Python code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n index = np.log(np.arange(1, len(bins) + 1)) ** 2\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity, penalize bins at maximum capacity, and prioritize bins with larger remaining capacities and smaller differences between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithmic function of the absolute difference between the item size and bin capacity raised to the power of 5, and the exponential function of the inverse of the bin index raised to the power of 2. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and larger exponential inverse bin indices.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_fifth_power = np.power(np.abs(bins - item), 5)\\n inverse_index_squared = np.exp(1 / np.log(np.arange(1, len(bins) + 1))) ** 2\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff_fifth_power)) - inverse_index_squared\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the quadratic function of the absolute difference between the item size and bin capacity raised to the power of 3, and the exponential function of the inverse of the bin index raised to the power of 4. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller third power differences between item size and bin capacity, and larger exponential inverse bin indices.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_third_power = np.power(np.abs(bins - item), 3)\\n inverse_index_quadratic = np.exp(1 / np.log(np.arange(1, len(bins) + 1))) ** 4\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff_third_power)) - inverse_index_quadratic\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 6, and the logarithmic function of the inverse of the bin index raised to the power of 4. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller sixth power differences between item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_sixth_power = np.power(np.abs(bins - item), 6)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 4\\n \\n scores = (bins - item) - np.log(np.abs(diff_sixth_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 6\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 4\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the absolute difference between the item size and bin capacity raised to the power of 7, and the exponential function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between item size and bin capacity, and smaller exponential inverse bin indices.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = np.exp(-1 / np.log(np.arange(1, len(bins) + 1))) ** 3\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity raised to the power of 9, the exponential of the inverse of the bin index raised to the power of 6, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller ninth power differences, larger inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.sqrt(np.abs(bins - item)) ** 9\\n inverse_index = np.exp(1 / np.arange(1, len(bins) + 1)) ** 6\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 7, and the logarithmic function of the inverse of the bin index raised to the power of 5. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between the item size and bin capacity, and smaller logarithmic inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 5\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 7, the logarithmic function of the inverse of the bin index raised to the power of 5, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller logarithmic inverse bin indices, and smaller penalty values.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 7\\n inverse_index = np.log(1 / np.arange(1, len(bins) + 1)) ** 5\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 5, and the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and smaller bin indices.\\n\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_fifth_power = np.power(np.abs(bins - item), 5)\\n bin_index_power = np.power(np.arange(1, len(bins) + 1), 3)\\n \\n scores = (bins - item) - np.log(np.abs(diff_fifth_power)) - bin_index_power\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 6, the logarithm of the inverse of the bin index raised to the power of 4, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n abs_diff = np.abs(bins - item) ** 6\\n penalty = 1\\n \\n scores = (bins - item) - np.log(abs_diff) + penalty\\n \\n scores[(bins == np.max(bins))] = 0\\n \\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize/penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the inverse of the bin index raised to the power of 3, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 3\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff)) - inverse_index + penalty\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm function of the absolute difference between the item size and bin capacity raised to the power of 2, and the exponential function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller second power differences between item size and bin capacity, and larger exponential inverse bin indices.\\n\\nPython code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_second_power = np.power(np.abs(bins - item), 2)\\n inverse_index_cubed = np.exp(1 / np.log(np.arange(1, len(bins) + 1))) ** 3\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff_second_power)) - inverse_index_cubed\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity, penalize bins at maximum capacity, and prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the absolute difference between the item size and bin capacity raised to the power of 7, and the inverse of the bin index raised to the power of 5. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller seventh power differences between item size and bin capacity, and smaller inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_seventh_power = np.power(np.abs(bins - item), 7)\\n inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 5\\n \\n scores = (bins - item) - np.log(np.abs(diff_seventh_power)) - inverse_index\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity, penalize bins at maximum capacity, and prioritize bins with larger remaining capacities and smaller differences between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity, and the exponential function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller square root differences between item size and bin capacity, and larger exponential inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item)\\n inverse_index_cubed = np.exp(1 / np.log(np.arange(1, len(bins) + 1))) ** 3\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index_cubed\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the natural logarithm of the absolute difference between the item size and bin capacity raised to the power of 6, the square root of the bin index raised to the power of 4, and the exponential function of the inverse of the item size raised to the power of 2. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller sixth power differences between item size and bin capacity, larger square root bin indices, and smaller exponential inverse item sizes.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_sixth_power = np.power(np.abs(bins - item), 6)\\n sqrt_bin_index_power = np.power(np.sqrt(np.arange(1, len(bins) + 1)), 4)\\n inverse_item_size_power = np.exp(-1 / np.log(item)) ** 2\\n \\n scores = (bins - item) - np.log(np.abs(diff_sixth_power)) - sqrt_bin_index_power + inverse_item_size_power\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/squared differences between the item size and bin capacity.\\n\\nThe new algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the logarithm of the absolute difference between the item size and bin capacity raised to the power of 7, the reciprocal of the logarithm of the bin index raised to the power of 5, and a penalty value proportional to the inverse of the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller bin indices, and smaller penalty values.\\n\\nPython code:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.log(np.abs(bins - item)) ** 7\\n log_inverse_index = 1 / np.log(np.arange(1, len(bins) + 1)) ** 5\\n penalty = 1 / (max_capacity - bins + 1)\\n \\n scores = (bins - item) - np.log(abs_diff) - log_inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the natural logarithm of the absolute difference between the item size and bin capacity raised to the power of 5, and the inverse of the bin index times the square root of the bin capacity raised to the power of 2. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller fifth power differences between item size and bin capacity, and smaller inverse bin indices multiplied by the square root of the bin capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff_fifth_power = np.power(np.abs(bins - item), 5)\\n inverse_index_capacity = 1 / np.sqrt(bins) * np.arange(1, len(bins) + 1)\\n \\n scores = (bins - item) - np.log(np.abs(abs_diff_fifth_power)) - inverse_index_capacity\\n \\n # Ensure that bins with maximum capacity are not used\\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for bins based on their remaining capacity, penalize bins at maximum capacity, and prioritize bins with larger remaining capacities and smaller differences between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the square root of the absolute difference between the item size and bin capacity, and the exponential function of the inverse of the bin index raised to the power of 3. It penalizes bins at maximum capacity and prioritizes bins with larger remaining capacities, smaller square root differences between item size and bin capacity, and larger exponential inverse bin indices.\\n\\nNew algorithm implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n sqrt_abs_diff = np.sqrt(np.abs(bins - item))\\n inverse_index_cubed = np.exp(1 / np.log(np.arange(1, len(bins) + 1))) ** 3\\n \\n scores = (bins - item) - np.log(sqrt_abs_diff) - inverse_index_cubed\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for bins based on their remaining capacity and penalize bins at maximum capacity. They also prioritize bins with larger remaining capacities and smaller differences/differences raised to a power between the item size and bin capacity.\\n\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the remaining capacity, the absolute difference between the item size and bin capacity raised to the power of 5, the inverse of the bin index raised to the power of 4, and a penalty based on the difference between the maximum capacity and the bin capacity, prioritizing bins with larger remaining capacities, smaller absolute differences, smaller inverse bin indices, and smaller penalty values.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n abs_diff = np.abs(bins - item) ** 5\\n inverse_index = 1 / np.arange(1, len(bins) + 1) ** 4\\n penalty = 1 / (1 + np.abs(bins - max_capacity))\\n \\n scores = (bins - item) - np.log(abs_diff) - inverse_index + penalty\\n \\n scores[(bins == max_capacity)] = 0\\n \\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the item size divided by the remaining capacity, raised to the power of 0.8, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity + (logarithm ** 0.8)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/TSRun3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function assigns items to bins based on the maximum score, while avoiding using bins at maximum capacity in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == np.max(bins)] = -1\\n scores = remaining_capacity / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with more remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, bins - item) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will assign a score to each bin based on the remaining capacity after placing the item. The score will be calculated by taking the reciprocal of the difference between the bin capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity. Higher scores indicate better candidates for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.15595,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm calculates the score for each bin based on the rest capacity and assigns the item to the bin with the maximum score, aiming to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = np.maximum(0, max_capacity - bins) # Calculate rest capacity\\n mask = rest_capacity < item # Check if rest capacity is enough for the item\\n rest_capacity[mask] = 0 # Set rest capacity to 0 if it's not enough\\n scores = rest_capacity / (max_capacity * (1 - mask)) # Calculate scores for each bin\\n return scores\",\n \"objective\": 0.31975,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the score for each bin by taking the ratio of the rest capacity to the item size, and then subtracting 1 if the rest capacity equals the maximum capacity, in order to prioritize the bin with the largest available space but not the maximum capacity, with the main steps being to calculate the scores and return them as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm as follows:\\nThe algorithm will calculate the score for each bin based on the remaining capacity after assigning the item, with a penalty for bins at maximum capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) - (bins == bins.max()) * (item + 1)\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the remaining capacity of each bin after assigning the item, and then assigns a score to each bin based on the ratio of remaining capacity to the maximum capacity, with a penalty for bins with maximum capacity. It then returns the scores for all bins using Numpy array. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_ratio = remaining_capacity / np.max(bins)\\n remaining_ratio[bins == np.max(bins)] -= 0.5 # Apply penalty for bins with maximum capacity\\n scores = remaining_ratio\\n return scores\",\n \"objective\": 0.40739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves ranking the bins based on their remaining capacity after assigning the item, and penalizing bins with maximum capacity to discourage their use. First, calculate the remaining capacity of each bin after assigning the item, then calculate the score for each bin by considering its remaining capacity and penalizing bins with maximum capacity. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalized_capacity = np.where(remaining_capacity < np.max(remaining_capacity), remaining_capacity, np.max(remaining_capacity) * 2)\\n scores = penalized_capacity * (1 + np.log(1 + np.abs(penalized_capacity - np.max(penalized_capacity))))\\n return scores\",\n \"objective\": 0.5735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the minimum between the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.maximum(bins - item, 0)\\n scores = np.minimum(capacities, item)\\n return scores\",\n \"objective\": 0.64021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: First, calculate the free space in each bin after adding the item, then compute the score for each bin using a novel formula that takes into account the free space and the distance from the maximum capacity, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_space = bins - item\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - remaining_space\\n scores = remaining_space * (1 + distance_from_max)\\n return scores\",\n \"objective\": 0.77412,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the following formula: score = (bin_capacity - item_size) * (1 - bin_index/N), where N is the total number of bins. Then, the function will return the scores for each bin in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n scores = (bins - item) * (1 - np.arange(N)/N)\\n return scores\",\n \"objective\": 0.89174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacity of each bin after adding the item, and then scores each bin based on the formula: ((maximum capacity - available capacity) / maximum capacity) * available capacity, where bins with the maximum capacity are not scored. Finally, the function returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n available_capacity = np.maximum(0, (bins + item) - max_capacity)\\n scores = ((max_capacity - available_capacity) / max_capacity) * available_capacity\\n scores[available_capacity == 0] = 0\\n return scores\",\n \"objective\": 1.21401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplementing the algorithm:\\n1. Create a function named score that accepts two input parameters: 'item' and 'bins'.\\n2. Inside the function, calculate the scores for each bin by first finding the difference between the maximum capacity of each bin and the size of the item.\\n3. For bins that have a rest capacity equal to the maximum capacity, assign a score of -1 to make them ineligible for item assignment.\\n4. Return the calculated scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == bins.max()).astype(int) * -1\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm: The algorithm first calculates the scores for each bin based on the rest capacity and the current item size, then it returns the scores for the bins for assignment.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0)\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, penalizes bins at maximum capacity and bins with rest capacity greater than or equal to the item size, and adds an additional penalty for bins that are significantly larger than the item size by subtracting a weighted difference between the bin capacity and the item size from the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + (bins >= item) * (max_capacity - bins) - 0.2 * (bins >= item) * (bins - item)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and the difference between the maximum capacity and the bin capacity. It also penalizes bins that have a rest capacity greater than or equal to the item size to encourage using smaller bins, and applies a penalty for bins at maximum capacity. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - (bins >= item) * (bins - item) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with less remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - np.maximum(0, bins - item)) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity and a weighted sum of the proximity to the item size and the position of the bin in the list of bins, and then returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = (max_capacity - bins) / (1 + proximity + 0.5*positions)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity, and adding a bonus for bins with remaining capacity equal to half of the maximum capacity, while also considering the proximity to the item size, in order to minimize the number of used bins by assigning items to the bin with the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - np.abs(bins - item) / (bins + 1)\\n scores += (bins == half_capacity) * item / 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. Unlike the previous algorithm, it also applies a penalty for bins that have a rest capacity greater than the item size, to encourage using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores[i] = bins[i] / (i + 1) * (1 + item / bins[i])\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(len(bins)) + 1) * (1 + item / bins)\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\nThe new algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the sum of the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum(bins + item)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on their remaining capacity after placing the item. It applies a penalty factor of 2 to bins that are already at maximum capacity, and utilizes vectorized operations for improved performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n remaining_capacity = max_capacity - bins\\n penalty_factor = 2\\n \\n scores = np.where(\\n remaining_capacity >= item,\\n np.reciprocal(remaining_capacity - item + 1) * (1 + penalty_factor),\\n np.reciprocal(remaining_capacity - item) * (1 + penalty_factor)\\n )\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity and a bonus for bins with remaining capacity equal to half of the maximum capacity. The scores will be returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - (bins == half_capacity) * item/2\\n return scores\",\n \"objective\": 0.04296,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, penalizing bins at maximum capacity and bins with rest capacity greater than the item size, and adds an additional penalty for bins that are significantly larger than the item size, in order to encourage efficient bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + (bins > item) * (max_capacity - bins) - 0.1 * (bins > item) * (bins - item)\\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. Unlike the previous algorithm, it also applies a penalty for bins that have a rest capacity greater than the item size, to encourage using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + (bins > item) * (max_capacity - bins)\\n return scores\",\n \"objective\": 0.04749,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) * np.exp(-np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.05453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The score function assigns items to bins based on a weighted combination of the remaining capacity and the square of the position of the bin in the list of bins, with higher scores for bins with less remaining capacity and lower positions, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins))**2)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.05514,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity. Additionally, the algorithm will penalize bins that are already partially filled, giving preference to bins with lower fill levels.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n scores -= np.arange(len(bins)) * 0.01 # Penalize bins with higher fill levels\\n return scores\",\n \"objective\": 0.05775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a weighted combination of the rest capacity and the square of the position of the bin in the list of bins, and then returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n scores = np.maximum(bins - item, 0) / (1 + positions**2)\\n return scores\",\n \"objective\": 0.07375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified formula that takes into account the remaining capacity and the proximity to the item size, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = (bins[i] - item) / (bins[i] + 1)\\n scores = scores / np.arange(1, len(bins) + 1)\\n return scores\",\n \"objective\": 0.07979,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n \\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a new nonlinear transformation to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) # New penalty component, log transformation\\n reward = np.sqrt(max_capacity) - np.sqrt(bins) # Existing reward component\\n \\n scores = 0.2*((reward / (1 + proximity))**2) + 0.5*ratio - 0.1*np.log(positions+1) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty # New nonlinear combination\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the ratio between the bin's capacity and the item size, the bin's position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores. The algorithm also includes a new term that penalizes bins that have a remaining capacity close to the maximum capacity, in order to encourage using bins that are not completely empty but also not completely full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins # Simplified penalty component\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 # New utilization penalty component\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) - 0.3*utilization_penalty\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25) # Changing the reward term to a fourth root of the bins\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins) # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the ratio between the bin's capacity and the item size, the position of the bin in the list, and the bin's proximity to the item size, while introducing additional penalty and reward terms and applying a weighted sum of these factors to determine the scores. The algorithm also incorporates a new term that penalizes bins with a remaining capacity close to the maximum capacity, promoting the use of bins that are neither completely empty nor completely full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) # New penalty component, log transformation\\n reward = np.sqrt(max_capacity) - np.sqrt(bins) # Existing reward component\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 # New utilization penalty component\\n \\n scores = 0.2*((reward / (1 + proximity))**2) + 0.5*ratio - 0.1*np.log(positions+1) + 0.2*(bins % item) - 0.4*(item % bins) - 0.3*utilization_penalty # New nonlinear combination\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a new nonlinear transformation to determine the scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) # New penalty component, log transformation\\n reward = np.sqrt(max_capacity) - np.sqrt(bins) # Existing reward component\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty # New nonlinear combination\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the bin's remaining capacity, the ratio between the bin's capacity and the item size, and the position of the bin in the list, while introducing new penalty and reward terms and applying a weighted sum of these factors to determine the scores. The algorithm also incorporates a new term that penalizes bins with a remaining capacity close to the maximum capacity, promoting the use of bins that are neither completely empty nor completely full. Additionally, it introduces a term that promotes the use of bins with a remaining capacity closer to the item size, enhancing the efficiency of bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) # New penalty component, log transformation\\n reward = np.sqrt(max_capacity) - np.sqrt(bins) # Existing reward component\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 # New utilization penalty component\\n size_efficiency = np.exp(-np.abs(max_capacity - 2*bins) / max_capacity) # New size efficiency component\\n \\n scores = 0.2*((reward / (1 + proximity))**2) + 0.5*ratio - 0.1*np.log(positions+1) + 0.2*(bins % item) - 0.4*(item % bins) - 0.3*utilization_penalty + 0.3*size_efficiency # New nonlinear combination\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item) / item # Modified proximity component\\n penalty = 0.1 # Simplified penalty component\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) / np.sqrt(max_capacity) # Modified reward component\\n \\n positions = np.arange(len(bins))\\n scores = 0.2*(reward / (1 + proximity)) + 0.5*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, and incorporates penalty/reward terms. However, it also introduces a novel scoring mechanism using mathematical functions such as exponential, logarithmic, and trigonometric functions, to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.exp(bins / item) * np.log(max_capacity) - np.log(bins) + np.sin(positions * np.pi / 2)\\n reward = np.sqrt(np.exp((max_capacity - bins) / max_capacity)) * np.sqrt(bins)\\n \\n scores = 0.4 * (penalty) / (1 + proximity) + 0.3 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list, while also considering additional penalty and reward terms. It utilizes trigonometric functions and exponential factors to achieve a unique scoring mechanism.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.sin(bins/item*np.pi/2)\\n reward = np.exp((max_capacity-bins)/max_capacity)\\n \\n scores = 0.35*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.15*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, penalizes bins at maximum capacity, and adjusts the scores based on the proximity to the item size and the position of the bin in the list. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation, while also considering the distance of the bin from the average capacity of all bins, taking into account the standard deviation of the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n avg_capacity = np.mean(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n distance_from_avg = np.abs(bins - avg_capacity)\\n std_dev = np.std(bins)\\n\\n scores = ((max_capacity - bins) / (1 + proximity)) - (positions * std_dev) + penalty - distance_from_avg\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to minimize the number of used bins by promoting the use of smaller bins, efficient allocation, and considering penalty/reward terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n \\n positions = np.arange(len(bins))\\n penalty = (bins % item) * (bins >= item)\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) * (bins < max_capacity)\\n\\n scores = 0.2 * (max_capacity - bins) / (1 + proximity) + 0.3 * ratio - 0.1 * positions + 0.2 * penalty - 0.3 * reward\\n \\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, using different parameter settings.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item) / item # Proximity component\\n penalty = 0.3 # Penalty component with different parameter setting\\n reward = 0.7 * (1 - (bins / np.max(bins))) # Reward component with different parameter setting\\n \\n positions = np.arange(len(bins))\\n scores = 0.2*(reward / (1 + proximity)) + 0.5*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and the ratio of the bin's capacity to the item size, while also considering the bin's position in the list and applying penalty/reward terms to determine the scores. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n \\n positions = np.arange(len(bins))\\n penalty = (bins % item) * (bins >= item)\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) * (bins < max_capacity)\\n\\n scores = (max_capacity - bins) / (1 + proximity) + ratio - positions * 0.1 + penalty - reward\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its proximity to the item size, its position in the list of bins, a penalty term based on the ratio of the bin's remaining capacity to the item size, and a reward term based on the square root of the bin's remaining capacity, while introducing a weighted sum of these factors and a penalty/reward term based on the remainder of the division between the bin size and the item size to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(ratio)\\n reward = np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the bin's remaining capacity, the item size, and a modified penalty term, with the aim of maximizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = (1 - np.exp(-ratio)) * (bins >= item) * (bins - item) # Modified penalty term\\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 2*positions) - np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n \\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(item - bins) / max_capacity\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = 0.25 * np.exp(-5 * proximity) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a new nonlinear transformation to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n distance = np.abs(bins - item) # Revised component: distance\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*((reward / (1 + distance))**2) + 0.5*ratio - 0.1*np.log(positions+1) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n1. The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the item size, the bin's position in the list of bins, and a penalty/reward term that encourages using bins that are not completely empty but also not completely full. The algorithm aims to minimize the number of used bins.\\n\\n2. The main steps of the algorithm are as follows:\\n a. Calculate the maximum capacity of the bins.\\n b. Calculate the proximity of each bin to the item (absolute difference between the bin and item).\\n c. Calculate the ratio between the capacity of each bin and the size of the item.\\n d. Generate an array of positions representing the position of each bin in the list.\\n e. Calculate a penalty term based on the difference between the maximum capacity and the capacity of each bin.\\n f. Calculate a reward term based on the logarithm of the maximum capacity plus one minus the logarithm of each bin capacity plus one.\\n g. Calculate an utilization penalty term based on the logarithm of the maximum capacity plus one minus the logarithm of each bin capacity plus one (similar to the reward term).\\n h. Compute the scores for each bin using a weighted sum of the above terms, with weights of 0.1 for reward/proximity, 0.6 for ratio, -0.2 for position, 0.1 for bins % item, -0.3 for item % bins, and -0.2 for utilization_penalty.\\n i. Return the computed scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins\\n reward = np.log(max_capacity+1) - np.log(bins+1)\\n utilization_penalty = np.log(max_capacity+1) - np.log(bins+1)\\n \\n scores = 0.1 * (reward / (1 + proximity)) + 0.6 * ratio - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.3 * (item % bins) - 0.2 * utilization_penalty\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the ratio between the bin's capacity and the item size, the bin's position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores. The algorithm also includes a new term that penalizes bins that have a remaining capacity close to the maximum capacity, in order to encourage using bins that are not completely empty but also not completely full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins # Simplified penalty component\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 # New utilization penalty component\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) - 0.3*utilization_penalty\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25) # Changing the reward term to a fourth root of the bins\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins) # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms. The algorithm will use a weighted sum of these factors to determine the scores, with different parameter settings compared to the original algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item) / item # Modified proximity component\\n penalty = 0.2 # Modified penalty component\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) / np.sqrt(max_capacity) # Modified reward component\\n \\n positions = np.arange(len(bins))\\n scores = 0.3*(reward / (1 + proximity)) + 0.4*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.5*(item % bins) + 0.2*(bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a new transformation to determine the scores that includes logarithmic and exponential components.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) \\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 \\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I named the function as score\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) \\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 \\n exponential = np.exp(-bins)\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty + 0.1*np.sin(positions) + 0.15*exponential + 0.25*(np.sin(proximity) / (1 + proximity))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the remaining capacities of the bins, the ratio between the bin's capacity and the item size, the position of the bin in the list, and additional penalty and reward terms, while incorporating a weighted sum of these factors to determine the scores. The algorithm also introduces a term that penalizes bins with a remaining capacity close to the maximum capacity, promoting the use of bins that are not completely empty nor completely full, and includes a term that promotes the use of bins with a remaining capacity closer to the item size, enhancing the efficiency of bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1\\n size_efficiency = np.exp(-np.abs(max_capacity - 2*bins) / max_capacity)\\n \\n scores = (0.2 * (reward / (1 + np.abs(bins - item)))**2) + (0.5 * ratio) - (0.1 * np.log(np.arange(len(bins))+1)) + (0.2 * (bins % item)) - (0.4 * (item % bins)) - (0.3 * utilization_penalty) + (0.3 * size_efficiency)\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The new algorithm modifies the parameter settings of the score function as follows:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item) / item # Modified proximity component\\n penalty = 0.1 # Simplified penalty component\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) / np.sqrt(max_capacity) # Modified reward component\\n \\n positions = np.arange(len(bins))\\n scores = 0.2*(reward / (1 + proximity)) + 0.5*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its proximity to the item size, its position in the list of bins, a penalty term based on the ratio of the bin's remaining capacity to the item size, and a reward term based on the square root of the bin's remaining capacity, while introducing a weighted sum of these factors and a penalty/reward term based on the remainder of the division between the bin size and the item size to determine the scores. Additionally, it includes a term based on the logarithm of the bin's position in the list to add complexity and promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(ratio)\\n reward = np.sqrt(bins)\\n log_position = np.log(positions + 1)\\n \\n scores = 0.2 * (penalty + reward) / (1 + proximity) + 0.5 * ratio - 0.1 * np.sqrt(positions) + 0.2 * (bins % item) - 0.4 * (item % bins) + 0.3 * log_position\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms. It uses a weighted sum of these factors to determine the scores, with different parameter settings compared to the existing algorithms. The algorithm incorporates various mathematical functions and mathematical operations to promote performance and self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = 1 / (1 + np.exp(-bins)) # S-shaped penalty term using the logistic function\\n reward = np.exp(-np.log(bins)) * np.sin(bins) # Exponential reward term with a sinusoidal component\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.4*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.2*(item % bins) # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the item size, their proximity, the position of the bin in the list, and additional penalty/reward terms, while utilizing complex mathematical functions and a weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.tanh((np.sin((bins - item) / max_capacity * np.pi / 4))**2)\\n reward = np.exp(-(np.cos((np.pi / 2) * bins / item))) / (1 + np.exp(-(np.sin((np.pi / 2) * bins / item))))\\n\\n scores = (0.2 * (penalty + reward) / (1 + proximity)) + (0.5 * bins / item) - (0.1 * np.sqrt(positions)) + (0.2 * (bins % item)) - (0.4 * (item % bins))\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, and incorporates penalty/reward terms. However, it also introduces a novel scoring mechanism using mathematical functions such as exponential, logarithmic, and trigonometric functions, to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.exp(bins / item) * np.log(max_capacity) - np.log(bins) + np.sin(positions * np.pi / 2)\\n reward = np.sqrt(np.exp((max_capacity - bins) / max_capacity)) * np.sqrt(bins)\\n \\n scores = 0.4 * (penalty) / (1 + proximity) + 0.3 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n \\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(item - bins) / max_capacity\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = 0.25 * np.exp(-5 * proximity) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, the proximity between the item size and the bins, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates complex mathematical functions to enhance the scoring process, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n proximity = np.abs(bins - item)\\n positions = np.arange(1, len(bins)+1)\\n \\n penalty = np.tanh(np.sin(bins) * np.cos(np.pi * item / bins) / (1 + np.exp(-bins*np.sin(bins))))\\n reward = (np.exp(np.cos(max_capacity)) / (1 + np.exp(-bins*np.sin(max_capacity))))**2\\n\\n scores = 0.3 * (penalty + reward) / (1 + ratio) + 0.4 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a transformation that incorporates exponential and trigonometric functions along with logarithmic components to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.exp(np.cos(bins)) # Exponential penalty term using cosine function\\n reward = np.sqrt(max_capacity) - np.sqrt(bins) # Square root reward term based on max capacity and current bin capacity\\n logarithmic = np.log(positions + 1) # Logarithmic component based on bin positions\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.4 * (bins / item) - 0.2 * logarithmic + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to each bin based on factors such as remaining capacity, proximity to the item size, position in the list, and penalty/reward terms. They combine these factors using a weighted sum or a combination of mathematical functions.\\n\\nNew algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm includes a novel component that calculates the scores using a combination of mathematical functions and weighted sums, while taking into account the characteristics of the bins and items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*((reward / (1 + proximity))**2) + 0.5*(bins / item) - 0.1*np.log(positions+1) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the remaining capacities of the bins, the item size, their proximity, the bin's position in the list, and penalty/reward terms, while introducing a new transformation that includes logarithmic, exponential, and trigonometric components.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(item - bins) / max_capacity\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(bins + 1) * np.sin(positions)\\n reward = np.exp(-np.abs(max_capacity - bins) / max_capacity)\\n \\n scores = 0.2 * np.log(1 + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.3 * penalty\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms using a combination of logarithmic, exponential, and sinusoidal functions, while incorporating a novel term that calculates the bin's capacity to item size ratio squared and inversely scales it exponentially using the natural logarithm function, with adjusted weights for each term, to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = 1 / (1 + np.exp(-bins)) # S-shaped penalty term using the logistic function\\n reward = np.exp(-np.log(bins)) * np.sin(bins) # Exponential reward term with a sinusoidal component\\n capacity_ratio = np.exp(-np.square(bins/item)*np.log(2)) # Novel term calculating the bin's capacity to item size ratio squared and inversely scaling it exponentially\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.35*(bins / item) - 0.15*np.sqrt(positions) + 0.05*(bins % item) - 0.15*(item % bins) + 0.15*capacity_ratio # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the ratio between the bin's capacity and the item size, the bin's position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores. The algorithm also includes a new term that penalizes bins that have a remaining capacity close to the maximum capacity, in order to encourage using bins that are not completely empty but also not completely full.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins # Simplified penalty component\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 # New utilization penalty component\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) - 0.3*utilization_penalty\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25) # Changing the reward term to a fourth root of the bins\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins) # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces a penalty term for large remaining capacities and a reward term for small remaining capacities, and uses a weighted sum of these factors to determine the scores. The new algorithm takes into account the difference between the item size and the remaining capacity of each bin, penalizes large differences, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a new transformation to determine the scores that includes logarithmic and exponential components.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) \\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 \\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{My new algorithm assigns scores to each bin by considering the remaining capacities of the bins, the ratio between the bin's capacity and the item size, the position of the bin in the list, and additional penalty and reward terms, while incorporating a weighted sum of these factors to determine the scores. The algorithm also includes a term that promotes the use of bins with a remaining capacity closer to the item size and a novel term that takes into account the proportion of remaining capacity to the maximum capacity.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + np.exp(-bins)) # Modified penalty term using the logistic function\\n reward = (np.exp(np.cos(max_capacity)) / (1 + np.exp(-bins*np.sin(max_capacity))))**2 # Modified reward term based on max capacity and current bin capacity\\n capacity_ratio = np.exp(-np.square(bins/max_capacity) * np.log(2)) # Novel term calculating the proportion of remaining capacity to the maximum capacity\\n \\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.35 * (bins / item) - 0.15 * np.sqrt(positions) + 0.05 * (bins % item) - 0.15 * (item % bins) + 0.15 * capacity_ratio\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"I named the function as score\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) \\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1 \\n exponential = np.exp(-bins)\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty + 0.1*np.sin(positions) + 0.15*exponential + 0.25*(np.sin(proximity) / (1 + proximity))\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the remaining capacities of the bins, the ratio between the bin's capacity and the item size, the position of the bin in the list, and additional penalty and reward terms, while incorporating a weighted sum of these factors to determine the scores. The algorithm also introduces a term that penalizes bins with a remaining capacity close to the maximum capacity, promoting the use of bins that are not completely empty nor completely full, and includes a term that promotes the use of bins with a remaining capacity closer to the item size, enhancing the efficiency of bin utilization.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = bins / item\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n utilization_penalty = np.exp((max_capacity - bins) / max_capacity) - 1\\n size_efficiency = np.exp(-np.abs(max_capacity - 2*bins) / max_capacity)\\n \\n scores = (0.2 * (reward / (1 + np.abs(bins - item)))**2) + (0.5 * ratio) - (0.1 * np.log(np.arange(len(bins))+1)) + (0.2 * (bins % item)) - (0.4 * (item % bins)) - (0.3 * utilization_penalty) + (0.3 * size_efficiency)\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(1 - (bins / item))\\n positions = np.arange(len(bins))\\n penalty = max_capacity / bins\\n reward = bins\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n \\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(item - bins) / max_capacity\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = 0.25 * np.exp(-5 * proximity) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to each bin based on factors such as remaining capacity, proximity to the item size, position in the list, and penalty/reward terms. They combine these factors using a weighted sum or a combination of mathematical functions.\\n\\nNew algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm includes a novel component that calculates the scores using a combination of mathematical functions and weighted sums, while taking into account the characteristics of the bins and items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*((reward / (1 + proximity))**2) + 0.5*(bins / item) - 0.1*np.log(positions+1) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(item / bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, penalty/reward terms, and a different weighting scheme for these factors. The algorithm aims to minimize the number of used bins by assigning the item to the bin with the maximum score, as long as the bin's rest capacity is not equal to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -1 * np.log(bins)\\n reward = np.power(bins, 0.25)\\n \\n scores = 0.3 * np.divide((penalty + reward), (1 + proximity)) + 0.5 * ratio - 0.1 * np.sqrt(positions) + 0.15 * np.mod(bins, item) - 0.65 * np.mod(item, bins)\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list, while incorporating a unique mathematical transformation and a complex weighted sum to determine the scores, resulting in a highly optimized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log1p(bins+1) - np.log1p(item+1)\\n reward = np.exp(-np.square(bins - item))\\n \\n scores = 0.4 * (penalty + reward) / (1 + proximity) + 0.6 * (bins / item) - 0.25 * np.sqrt(positions) + 0.15 * (bins % item) - 0.5 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25) # Changing the reward term to a fourth root of the bins\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins) # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins)\\n # Adjusting the weights for each term\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.3*ratio - 0.05*np.sqrt(positions) + 0.1*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces a penalty term for large remaining capacities and a reward term for small remaining capacities, and uses a weighted sum of these factors to determine the scores. The new algorithm takes into account the difference between the item size and the remaining capacity of each bin, penalizes large differences, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin by taking into account the bin's remaining capacity, the proximity of the item size to the bin capacity, the logarithmic transformation of the bin's position, and a customized penalty term for bins with maximum capacity, while incorporating a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(item - bins) / max_capacity\\n positions = np.log(np.arange(1, len(bins)+1))\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = 0.3 * np.exp(-5 * proximity) / (1 + proximity) + 0.4 * (bins / item) - 0.2 * positions + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.5 * penalty\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms with a different parameter setting than the original algorithm, using a combination of mathematical functions to calculate the scores. The weights for each term are adjusted to achieve the desired scoring. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.sin(np.power(bins, 0.33)) # Changing the reward term to a sine of a power function of the bins\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.3*ratio - 0.1*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins) # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(np.arange(len(bins))) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and incorporates mathematical functions and weighted sums to determine the scores, resulting in a unique and optimized scoring scheme. The algorithm utilizes non-linear transformations and explicit consideration of bin and item characteristics to enhance the scoring process and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins) - np.log(item)\\n reward = np.exp(bins) / np.exp(max_capacity)\\n \\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(1 - (bins / item))\\n positions = np.arange(len(bins))\\n penalty = max_capacity / bins\\n reward = bins\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n \\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(item - bins) / max_capacity\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = 0.25 * np.exp(-5 * proximity) / (1 + proximity) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(item / bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25) # Changing the reward term to a fourth root of the bins\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins) # Adjusting the weights for each term\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins)\\n # Adjusting the weights for each term\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.3*ratio - 0.05*np.sqrt(positions) + 0.1*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces a penalty term for large remaining capacities and a reward term for small remaining capacities, and uses a weighted sum of these factors to determine the scores. The new algorithm takes into account the difference between the item size and the remaining capacity of each bin, penalizes large differences, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(np.arange(len(bins))) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the logarithm of the bin's position in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.log(np.arange(1, len(bins)+1))\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * positions + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(1 - (bins / item))\\n positions = np.arange(len(bins))\\n penalty = max_capacity / bins\\n reward = bins\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. Additionally, it includes a penalty term based on the difference between the maximum capacity and the bin's capacity, and a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity - bins + 1)\\n reward = np.sqrt(bins)\\n\\n scores = 0.3*(penalty + reward) / (proximity + 0.5) + 0.5*(bins / item) - 0.1*np.sqrt(positions) + 0.05*(bins % item) - 0.2*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, the logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and the reward term based on the square root of the bin's capacity. It also includes additional terms involving proportionalities and exponential functions to enhance the scoring process and achieve a unique scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = max_capacity / bins\\n reward = np.sqrt(bins) * np.exp(-(max_capacity / bins)**2)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(item / bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, a penalty term for bins with maximum capacity, and a bonus for bins with a rest capacity greater than twice the item size. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n bonus = np.where(bins > 2*item, 0.15, 0)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty + bonus\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins)\\n # Adjusting the weights for each term\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.3*ratio - 0.05*np.sqrt(positions) + 0.1*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces a penalty term for large remaining capacities and a reward term for small remaining capacities, and uses a weighted sum of these factors to determine the scores. The new algorithm takes into account the difference between the item size and the remaining capacity of each bin, penalizes large differences, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(np.arange(len(bins))) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the position of the bin in the list, the item size, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions, weighted sums, and element-wise operations to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n\\n scores = 0.4 * (bins / item) - 0.15 * np.sqrt(np.arange(1, len(bins)+1)) + 0.1 * (bins % item) - 0.35 * (item % bins) + 0.1 * penalty\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the logarithm of the bin's position in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.log(np.arange(1, len(bins)+1))\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * positions + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(1 - (bins / item))\\n positions = np.arange(len(bins))\\n penalty = max_capacity / bins\\n reward = bins\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. Additionally, it includes a penalty term based on the difference between the maximum capacity and the bin's capacity, and a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity - bins + 1)\\n reward = np.sqrt(bins)\\n\\n scores = 0.3*(penalty + reward) / (proximity + 0.5) + 0.5*(bins / item) - 0.1*np.sqrt(positions) + 0.05*(bins % item) - 0.2*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, the logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and the reward term based on the square root of the bin's capacity. It also includes additional terms involving proportionalities and exponential functions to enhance the scoring process and achieve a unique scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = max_capacity / bins\\n reward = np.sqrt(bins) * np.exp(-(max_capacity / bins)**2)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, a penalty term for bins with maximum capacity, and a bonus for bins with a rest capacity greater than twice the item size. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins > avg_capacity, bins/avg_capacity, 1)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(item / bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, and the average capacity of the bins. It uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations, explicit consideration of the characteristics of the bins and items, and the average capacity to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n average_capacity = np.mean(bins)\\n\\n scores = 0.4 / (1 + proximity) + 0.5 * (bins / item) - 0.3 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.3 * (bins / average_capacity)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores, with a different parameter setting than the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.power(bins, 0.25)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.4*ratio - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.55*(item % bins)\\n # Adjusting the weights for each term\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.3*ratio - 0.05*np.sqrt(positions) + 0.1*(bins % item) - 0.5*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(np.arange(len(bins))) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the position of the bin in the list, the item size, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions, weighted sums, and element-wise operations to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n\\n scores = 0.4 * (bins / item) - 0.15 * np.sqrt(np.arange(1, len(bins)+1)) + 0.1 * (bins % item) - 0.35 * (item % bins) + 0.1 * penalty\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.25 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the logarithm of the bin's position in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.log(np.arange(1, len(bins)+1))\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * positions + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n bin_ratio = bins / item\\n \\n scores = 0.5 * bin_ratio - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(item) # simplified penalty\\n reward = np.sqrt(item) # simplified reward\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of weighted sum and a logarithmic function to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = np.exp(0.4 * np.log(penalty + 1) / (1 + proximity) + 0.6 * (bins / item) - 0.3 * np.log(positions + 1) + 0.15 * (bins % item) - 0.5 * (item % bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 0.7 * (bins / item) - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(item / bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, and the average capacity of the bins. It uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations, explicit consideration of the characteristics of the bins and items, and the average capacity to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n average_capacity = np.mean(bins)\\n\\n scores = 0.4 / (1 + proximity) + 0.5 * (bins / item) - 0.3 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.3 * (bins / average_capacity)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = bins / item\\n positions = np.arange(len(bins))\\n penalty = bins / item\\n scores = 0.3 * (penalty) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(np.arange(len(bins))) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the position of the bin in the list, the item size, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions, weighted sums, and element-wise operations to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n\\n scores = 0.4 * (bins / item) - 0.15 * np.sqrt(np.arange(1, len(bins)+1)) + 0.1 * (bins % item) - 0.35 * (item % bins) + 0.1 * penalty\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size, the remaining capacities of the bins, and their position in the list, using mathematical functions such as exponentials, trigonometric functions, and logarithms to create a more complex scoring mechanism.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n weights = np.exp(-positions) - np.cos(np.pi * positions) + np.log(1 + positions)\\n scores = 0.3 * ((np.exp(-proximity))**2 + (np.cos(np.pi * proximity))**2) / (1 + proximity + weights) + 0.6 * ratio - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the ratio between the item size and the bin capacity, and the logarithm of the bin's position in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratio = item / bins\\n positions = np.log(np.arange(1, len(bins)+1))\\n penalty = np.log(max_capacity / bins)\\n reward = np.sqrt(max_capacity / bins)\\n\\n scores = 0.25 * (penalty + reward) / (1 + ratio) + 0.5 * (bins / item) - 0.15 * positions + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n bin_ratio = bins / item\\n \\n scores = 0.5 * bin_ratio - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = 1 / (1 + np.abs(bins - item))\\n positions = np.arange(len(bins))\\n penalty = np.log(np.abs(item / bins))\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'scores': [np.float64]\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n ratio = item / bins\\n log_capacity = np.log(bins)\\n\\n scores = 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty + 0.2 * (ratio * log_capacity)\\n\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 0.7 * (bins / item) - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + np.abs(bins - item)) + 0.7 * (bins / item) - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_ratio = bins / item\\n \\n scores = 0.5 * bin_ratio - 0.2 * np.sqrt(bin_ratio) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = 1 / (1 + np.sqrt((bins - item)**2))\\n positions = np.arange(len(bins))\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, and the average capacity of the bins. It uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations, explicit consideration of the characteristics of the bins and items, and the average capacity to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n average_capacity = np.mean(bins)\\n\\n scores = 0.4 / (1 + proximity) + 0.5 * (bins / item) - 0.3 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.3 * (bins / average_capacity)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = bins / item\\n positions = np.arange(len(bins))\\n penalty = bins / item\\n scores = 0.3 * (penalty) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(np.arange(len(bins))) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the position of the bin in the list, the item size, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions, weighted sums, and element-wise operations to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n\\n scores = 0.4 * (bins / item) - 0.15 * np.sqrt(np.arange(1, len(bins)+1)) + 0.1 * (bins % item) - 0.35 * (item % bins) + 0.1 * penalty\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n ratio = item / bins\\n log_capacity = np.log(bins)\\n\\n scores = 0.4 * (bins / item) - 0.15 * np.sqrt(positions) + 0.05 * (bins % item) - 0.3 * (item % bins) + 0.2 * (proximity / max_capacity) + 0.1 * (ratio * log_capacity)\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = item / bins\\n scores = 0.3 * (penalty) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n bin_ratio = bins / item\\n \\n scores = 0.5 * bin_ratio - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, the logarithm of the bin's capacity, and the logarithm of the item size, while using a weighted sum of these factors to determine the scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n \\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.3 * np.log(bins) - 0.3 * np.log(item)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.sqrt(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 0.7 * (bins / item) - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + np.abs(bins - item)) + 0.7 * (bins / item) - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_ratio = bins / item\\n \\n scores = 0.5 * bin_ratio - 0.2 * np.sqrt(bin_ratio) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = 1 / (1 + np.sqrt((bins - item)**2))\\n positions = np.arange(len(bins))\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the proximity of the item size to the bin capacity, the position of the bin in the list, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions and weighted sum to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(1, len(bins)+1)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n \\n scores = + 0.5 * (bins / item) - 0.15 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * penalty\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = bins - item\\n positions = np.arange(len(bins))\\n\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, and the average capacity of the bins. It uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations, explicit consideration of the characteristics of the bins and items, and the average capacity to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n average_capacity = np.mean(bins)\\n\\n scores = 0.4 / (1 + proximity) + 0.5 * (bins / item) - 0.3 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.3 * (bins / average_capacity)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores. The algorithm incorporates a logarithmic penalty term based on the ratio of the maximum capacity to the bin's capacity, and includes a reward term based on the square root of the bin's capacity. The scores are computed using a combination of these factors, with different weightings and adjustments compared to the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(bins)\\n\\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.6*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.3*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = bins / item\\n positions = np.arange(len(bins))\\n penalty = bins / item\\n scores = 0.3 * (penalty) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity, and incorporating a variable penalty based on the item size and its relationship with the bin capacities, as well as adjusting the scores based on the bin's position in the list with a scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins)\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. It also applies a penalty for bins that have a rest capacity greater than twice the item size, to encourage using smaller bins. Finally, it multiplies the scores by the square root of the remaining capacity, to further promote using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item - (bins > 2*item) * item - np.sqrt(bins)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin by dividing the remaining capacity by the item size, applying a penalty for bins at maximum capacity, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions)\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a lower penalty for bins at maximum capacity and a higher bonus for bins with remaining capacity equal to half of the maximum capacity. The scores will be returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item/2 - (bins == half_capacity) * item\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n # Modified scoring formula\\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions) - np.log(positions+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity and penalizes bins at maximum capacity, while also considering the ratio of the item size to the bin capacity and adding a bonus for bins with remaining capacity equal to half of the maximum capacity, in order to minimize the number of used bins by assigning items to the bin with the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) - (bins == max_capacity) * item + (item / bins)\\n scores += (bins == half_capacity) * (item * 2)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and the difference between the maximum capacity and the bin capacity. It also penalizes bins that have a rest capacity greater than or equal to the item size to encourage using smaller bins, and applies a penalty for bins at maximum capacity. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - (bins >= item) * (bins - item) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins. It then applies a modified scoring formula that puts more weight on the remaining capacity and less weight on the proximity and position, returning the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + 0.5*proximity)) + (1 - 0.25*positions)\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Simplified scoring formula\\n scores = 1 - bins / np.max(bins)\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the proximity to the item size, and the position of the bin in the list of bins, and then applies a modified scoring formula that puts more weight on the remaining capacity and less weight on the proximity and position, returning the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.25*positions)\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_capacity = np.max(bins)\\n proximity = np.abs(bins - item) / max_bin_capacity\\n \\n # Modified scoring formula\\n scores = (1 - bins) / (1 + proximity) - np.log(np.arange(1, len(bins)+1))\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity and a weighted sum of the proximity to the item size and the position of the bin in the list of bins, and then returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = (max_capacity - bins) / (1 + proximity + 0.5*positions)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a higher penalty for bins at maximum capacity and a lower bonus for bins with remaining capacity equal to half of the maximum capacity. The scores are returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) - (bins == max_capacity) * (item * 2) + (bins == half_capacity) * (item * 0.5)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"It calculates the scores for each bin by considering the remaining capacity, the position, and the size difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n size_difference = max_capacity - item - bins\\n \\n scores = (max_capacity - bins) + 0.5 * positions - 0.2 * size_difference\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity, and adding a bonus for bins with remaining capacity equal to half of the maximum capacity, while also considering the proximity to the item size, in order to minimize the number of used bins by assigning items to the bin with the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - np.abs(bins - item) / (bins + 1)\\n scores += (bins == half_capacity) * item / 2\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. Unlike the previous algorithm, it also applies a penalty for bins that have a rest capacity greater than the item size, to encourage using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores[i] = bins[i] / (i + 1) * (1 + item / bins[i])\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.arange(len(bins)) + 1) * (1 + item / bins)\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the remaining capacity, using a penalty for bins at maximum capacity and a bonus for bins with remaining capacity equal to three-fourths of the maximum capacity. The scores will be returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n three_fourths_capacity = (3/4) * max_capacity\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - (bins == three_fourths_capacity) * item/2\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the logarithm of the remaining capacity divided by the item size, applying a penalty for bins at maximum capacity, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = np.log(bins / item) - (bins == max_capacity) + (1 - 0.5 * positions)\\n \\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(np.arange(len(bins))) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the position of the bin in the list, the item size, and a penalty term for bins with maximum capacity. It uses a combination of mathematical functions, weighted sums, and element-wise operations to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = np.where(bins == max_capacity, 1, 0)\\n\\n scores = 0.4 * (bins / item) - 0.15 * np.sqrt(np.arange(1, len(bins)+1)) + 0.1 * (bins % item) - 0.35 * (item % bins) + 0.1 * penalty\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(bins+1) - np.log(item+1)\\n reward = (np.exp(max_capacity) - np.exp(bins)) / (np.exp(max_capacity) + np.exp(bins))\\n\\n scores = 0.3 * (penalty + reward) / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the logarithm of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n ratio = item / bins\\n log_capacity = np.log(bins)\\n\\n scores = 0.4 * (bins / item) - 0.15 * np.sqrt(positions) + 0.05 * (bins % item) - 0.3 * (item % bins) + 0.2 * (proximity / max_capacity) + 0.1 * (ratio * log_capacity)\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = item / bins\\n scores = 0.3 * (penalty) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n bin_ratio = bins / item\\n \\n scores = 0.5 * bin_ratio - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n\\n scores = 0.3 / (1 + proximity) + 0.5 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, the logarithm of the bin's capacity, and the logarithm of the item size, while using a weighted sum of these factors to determine the scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n \\n scores = 0.5 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.3 * np.log(bins) - 0.3 * np.log(item)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n positions = np.arange(len(bins))\\n\\n scores = 0.5 * (bins / item) - 0.2 * np.sqrt(positions + 1) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = item / bins\\n reward = bins\\n\\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 0.7 * (bins / item) - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors related to the item size and the remaining capacities of the bins. It penalizes large differences between the item size and the bin capacity, rewards small differences, and also considers the proximity of the bin to the item and the position of the bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.where(bins > item, bins - item, 0)\\n reward = np.where(bins < item, item - bins, 0)\\n \\n scores = 0.3 * (penalty + reward) / (1 + np.abs(bins - item)) + 0.7 * (bins / item) - 0.2 * np.sqrt(np.arange(len(bins))) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_ratio = bins / item\\n \\n scores = 0.5 * bin_ratio - 0.2 * np.sqrt(bin_ratio) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity, while using a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = 1 / (1 + np.sqrt((bins - item)**2))\\n positions = np.arange(len(bins))\\n reward = np.sqrt(bins)\\n\\n scores = 0.15*(reward) / (1 + proximity) + 0.5*(bins / item) - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, and their proximity, using a combination of mathematical functions, weighted sums, and element-wise operations to determine the scores. It incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme that promotes performance and self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n scores = 0.4 * (bins / item) - 0.2 * np.log(positions + 1) + 0.1 * (bins % item) - 0.3 * (item % bins) + 0.2 / (1 + proximity)\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin by taking into account the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list, using a combination of mathematical operations (multiplication, division, subtraction, and addition) to determine the scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n capacity_ratio = bins / item\\n\\n scores = 0.15 * ((1 + bins) / (1 + proximity)) + 0.5 * capacity_ratio - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins)\\n\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, and the average capacity of the bins. It uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations, explicit consideration of the characteristics of the bins and items, and the average capacity to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n average_capacity = np.mean(bins)\\n\\n scores = 0.4 / (1 + proximity) + 0.5 * (bins / item) - 0.3 * np.sqrt(positions) + 0.1 * (bins % item) - 0.5 * (item % bins) + 0.3 * (bins / average_capacity)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin by considering the bin's remaining capacity, the item size, their proximity, the position of the bin in the list, the ratio of the item size to the bin's remaining capacity, and the square root of the bin's capacity using a different set of parameter values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_ratio = bins / item\\n \\n scores = 0.7 * bin_ratio - 0.3 * np.sqrt(bin_ratio) + 0.2 * (bins % item) - 0.6 * (item % bins)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a combination of mathematical functions and weighted sums to determine the scores. The algorithm incorporates non-linear transformations and explicit consideration of the characteristics of the bins and items to enhance the scoring process, resulting in a unique and customized scoring scheme.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = bins / item\\n positions = np.arange(len(bins))\\n penalty = bins / item\\n scores = 0.3 * (penalty) / (1 + proximity) + 0.7 * (bins / item) - 0.2 * np.sqrt(positions) + 0.1 * (bins % item) - 0.4 * (item % bins) + 0.2 * (bins / np.mean(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, and the position in the list of bins, while also incorporating a penalty term for bins with larger remaining capacities and rewarding bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = (np.log(max_capacity) - np.log(bins)) / (1 + proximity) + ratio - np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity, and incorporating a variable penalty based on the item size and its relationship with the bin capacities, as well as adjusting the scores based on the bin's position in the list with a scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins)\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. It also applies a penalty for bins that have a rest capacity greater than twice the item size, to encourage using smaller bins. Finally, it multiplies the scores by the square root of the remaining capacity, to further promote using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins + (bins == np.max(bins)) * item - (bins > 2*item) * item - np.sqrt(bins)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by penalizing bins with larger remaining capacities, rewarding bins with smaller remaining capacities, incorporating a penalty term based on item size and its relationship with bin capacities, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n remaining_capacity = max_capacity - bins\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions) - np.log(positions+1) + np.exp(-item / bins)\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin by dividing the remaining capacity by the item size, applying a penalty for bins at maximum capacity, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions)\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a lower penalty for bins at maximum capacity and a higher bonus for bins with remaining capacity equal to half of the maximum capacity. The scores will be returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item/2 - (bins == half_capacity) * item\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n # Modified scoring formula\\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions) - np.log(positions+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a higher penalty for bins at maximum capacity and a higher bonus for bins with remaining capacity equal to half of the maximum capacity. The scores are returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) - (bins == max_capacity) * (item * 2) + (bins == half_capacity) * (item * 2)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the remaining capacity, the logarithm of the difference between the bin capacity and item size, and a weighted linear combination of the bin's position and proximity to the item size, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n capacity_difference = np.log(max_capacity - item)\\n\\n scores = (max_capacity - bins) + (0.6 - 0.15 * np.arange(len(bins))) + (0.8 - 0.1 * proximity) - (0.25 * np.arange(len(bins)) * proximity) - capacity_difference\\n \\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and the difference between the maximum capacity and the bin capacity. It also penalizes bins that have a rest capacity greater than or equal to the item size to encourage using smaller bins, and applies a penalty for bins at maximum capacity. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - (bins >= item) * (bins - item) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, the position in the list, and the relationship between the bin capacity and the item size. It penalizes bins with lower remaining capacity, adjusts the scores based on the bin's position, and incorporates a scaling factor based on the item size and its relationship with the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n remaining_capacity = max_capacity - bins\\n item_ratio = item / (bins - item)\\n \\n scores = (1 / (remaining_capacity + 1)) + (1 - 0.5 * positions) * item_ratio\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm incorporates the logarithmic function of the capacity to further penalize bins with higher remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n capacity_log = np.log(bins+1) # Incorporate logarithmic function of capacity\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions) - capacity_log\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the remaining capacity, the similarity to the item size, and their position in the list of bins, and returns the scores for the bins for assignment. The new algorithm uses a different weighting for each parameter, with emphasis on the remaining capacity and proximity to the item size, while giving less weight to the position in the list of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (0.8 - 0.2 * np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. Unlike the previous algorithm, it also applies a penalty for bins that have a rest capacity greater than the item size, to encourage using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = 2*max_capacity - bins - item\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, giving a higher score to bins with smaller remaining capacity. It also applies a penalty for bins that have a rest capacity greater than twice the item size, to encourage using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + np.clip(bins - 2*item, 0, None)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_capacity = np.max(bins)\\n proximity = np.abs(bins - item) / max_bin_capacity\\n \\n # Modified scoring formula\\n scores = (1 - bins) / (1 + proximity) - np.log(np.arange(1, len(bins)+1))\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity and a weighted sum of the proximity to the item size and the position of the bin in the list of bins, and then returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = (max_capacity - bins) / (1 + proximity + 0.5*positions)\\n \\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a higher penalty for bins at maximum capacity and a lower bonus for bins with remaining capacity equal to half of the maximum capacity. The scores are returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) - (bins == max_capacity) * (item * 2) + (bins == half_capacity) * (item * 0.5)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"It calculates the scores for each bin by considering the remaining capacity, the position, and the size difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n size_difference = max_capacity - item - bins\\n \\n scores = (max_capacity - bins) + 0.5 * positions - 0.2 * size_difference\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the inverse of the proximity to the item size, the logarithm of the remaining capacity, and the position in the list of bins, while also incorporating a reward term for bins with smaller remaining capacities and penalizing bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n rewards = 1 / (proximity + 1)\\n penalties = np.log(max_capacity) - np.log(bins)\\n \\n scores = ratio * rewards - penalties + np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins. It applies a penalty for bins at maximum capacity and includes a logarithmic term to further adjust the scores based on their position. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to the item size, aiming to encourage the use of smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, and the position in the list of bins, while also incorporating a penalty term for bins with larger remaining capacities and rewarding bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = (np.log(max_capacity) - np.log(bins)) / (1 + proximity) + ratio - np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and incorporates a variable penalty based on the item size and its relationship with the bin capacities. It also adjusts the scores based on the bin's position in the list with a scaling factor. The algorithm aims to minimize the number of used bins by assigning items to bins with higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins) - (item > 0.5 * bins) * 0.5\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity, and incorporating a variable penalty based on the item size and its relationship with the bin capacities, as well as adjusting the scores based on the bin's position in the list with a scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins)\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. It also applies a penalty for bins that have a rest capacity greater than twice the item size, to encourage using smaller bins. Finally, it multiplies the scores by the square root of the remaining capacity, to further promote using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins + (bins == np.max(bins)) * item - (bins > 2*item) * item - np.sqrt(bins)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by penalizing bins with larger remaining capacities, rewarding bins with smaller remaining capacities, incorporating a penalty term based on item size and its relationship with bin capacities, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n remaining_capacity = max_capacity - bins\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions) - np.log(positions+1) + np.exp(-item / bins)\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin by dividing the remaining capacity by the item size, applying a penalty for bins at maximum capacity, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions)\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a lower penalty for bins at maximum capacity and a higher bonus for bins with remaining capacity equal to half of the maximum capacity. The scores will be returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item/2 - (bins == half_capacity) * item\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n # Modified scoring formula\\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions) - np.log(positions+1)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a higher penalty for bins at maximum capacity and a higher bonus for bins with remaining capacity equal to half of the maximum capacity. The scores are returned in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) - (bins == max_capacity) * (item * 2) + (bins == half_capacity) * (item * 2)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and the difference between the maximum capacity and the bin capacity. It also penalizes bins that have a rest capacity equal to or greater than twice the item size to encourage using smaller bins, and applies a penalty for bins at maximum capacity. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (2 * (max_capacity - bins)) - (2 * (bins >= 2 * item) * (bins - 2 * item)) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity and the difference between the maximum capacity and the bin capacity. It also penalizes bins that have a rest capacity greater than or equal to the item size to encourage using smaller bins, and applies a penalty for bins at maximum capacity. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - (bins >= item) * (bins - item) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, the position in the list, and the relationship between the bin capacity and the item size. It penalizes bins with lower remaining capacity, adjusts the scores based on the bin's position, and incorporates a scaling factor based on the item size and its relationship with the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n remaining_capacity = max_capacity - bins\\n item_ratio = item / (bins - item)\\n \\n scores = (1 / (remaining_capacity + 1)) + (1 - 0.5 * positions) * item_ratio\\n \\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on a combination of the ratio between the remaining capacity and the item size, the proximity to the item size, the position in the list of bins, and a penalty term that encourages using bins with smaller remaining capacities. The score is then calculated such that bins with larger remaining capacities will receive a lower score, and bins with smaller remaining capacities will receive a higher score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = np.log(max_capacity) / (1 + proximity) + ratio - np.sqrt(positions) - np.log(bins)\\n \\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, and returns the scores for the bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions)\\n \\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the remaining capacity, the similarity to the item size, and their position in the list of bins, and returns the scores for the bins for assignment. The new algorithm uses a different weighting for each parameter, with emphasis on the remaining capacity and proximity to the item size, while giving less weight to the position in the list of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (0.8 - 0.2 * np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, giving a higher score to bins with smaller remaining capacity. It also applies a penalty for bins that have a rest capacity greater than twice the item size, to encourage using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins + np.clip(bins - 2*item, 0, None)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins, with a modified formula for calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item) / np.max(bins)\\n \\n # Modified scoring formula\\n scores = (1 - bins) / (1 + proximity) - np.log(np.arange(len(bins))+1)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, incorporating a penalty for bins at maximum capacity, and adjusting the scores based on the proximity to the item size and the bin's position in the list, aiming to minimize the number of used bins. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to twice the item size, further encouraging the use of smaller bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + penalty\\n \\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) + ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the inverse of the proximity to the item size, the logarithm of the remaining capacity, and the position in the list of bins, while also incorporating a reward term for bins with smaller remaining capacities and penalizing bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n rewards = 1 / (proximity + 1)\\n penalties = np.log(max_capacity) - np.log(bins)\\n \\n scores = ratio * rewards - penalties + np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins. It applies a penalty for bins at maximum capacity and includes a logarithmic term to further adjust the scores based on their position. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to the item size, aiming to encourage the use of smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and adjusts the scores based on the bin's position in the list with a scaling factor. It also introduces a penalty-term for bins with a rest capacity greater than or equal to twice the item size, aiming to encourage the use of smaller bins. Additionally, it applies a reward term for bins with rest capacity less than or equal to half of the maximum capacity, to encourage efficient utilization of larger bins, and incorporates a logarithmic term to further adjust the scores based on their position in the list. The scores are returned as a Numpy array with a modification to the penalty term, where bins with rest capacity greater than or equal to twice the item size are penalized by the squared difference from the item size divided by the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * ((item - bins)**2 / bins)\\n reward = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty + reward\\n \\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm prioritizes bins with smaller remaining capacities, penalizes bins at or near maximum capacity, and adjusts the scores based on their position in the list. It also incorporates a penalty term based on the item size and its relationship with the bin capacities, aiming to minimize the number of used bins. Additionally, it introduces a logarithmic term to further modify the scores based on their position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * (bins - 2*item)\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, the position in the list of bins, and the penalty term for bins with larger remaining capacities. Besides, it also includes a reward term for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) + ratio - np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, and the position in the list of bins, while also incorporating a penalty term for bins with larger remaining capacities and rewarding bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = (np.log(max_capacity) - np.log(bins)) / (1 + proximity) + ratio - np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to minimize the number of used bins by calculating the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity and bins with a rest capacity greater than the item size, and rewarding bins with smaller remaining capacities. It also adjusts the scores based on the bin's position in the list by applying a scaling factor, and incorporates a penalty term based on the item size and its relationship with the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n scaling_factor = 0.3 # Adjust the scaling factor to control the influence of the bin's position in the list\\n \\n scores = (penalty + reward) / (1 + proximity) + (bins / item) - (bins == max_capacity) + (1 - scaling_factor * positions) * (item / bins)\\n \\n return scores\",\n \"objective\": 0.03421,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and adjusts the scores based on the bin's position in the list with a scaling factor. Additionally, it incorporates a variable penalty based on the item size and its relationship with the bin capacities, aiming to minimize the number of used bins by assigning items to bins with higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins) - (item > 0.75 * bins) * 0.5\\n \\n return scores\",\n \"objective\": 0.03451,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with penalties for bins at maximum capacity and for bins with a rest capacity greater than twice the item size, and applies a reward for bins with smaller remaining capacities. It also incorporates a penalty term based on the item size and its relationship with the bin capacities, and adjusts the scores based on the bin's position in the list with a scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) + (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins)\\n \\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is designed to prioritize bins with closer remaining capacity to the item size, penalize bins at or near maximum capacity, and provide a bonus for bins with rest capacity less than or equal to half of the maximum capacity. It also incorporates a logarithmic term to adjust the scores based on the position of the bins in the list, aiming to minimize the number of used bins by assigning items to bins with higher scores. Lastly, it includes a variable penalty based on the item size and its relationship with the bin capacities to further fine-tune the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2.5*item) * (bins - 2.5*item)\\n bonus = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (2 - 0.5*positions) + np.log(positions + 1) + penalty + bonus\\n \\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin by dividing the remaining capacity by the item size, applying a penalty for bins at maximum capacity, adding a bonus for bins with remaining capacity equal to the item size, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n remaining_capacity = bins - item\\n \\n scores = (remaining_capacity / item) - (bins == max_capacity) + (bins == item) + (1 - 0.5 * positions)\\n \\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and adjusts the scores based on the bin's position in the list with a scaling factor. It also introduces a penalty-term for bins with a rest capacity greater than or equal to three times the item size, aiming to encourage the use of smaller bins. Additionally, it applies a reward term for bins with rest capacity less than or equal to half of the maximum capacity, to encourage efficient utilization of larger bins, and incorporates a logarithmic term to further adjust the scores based on their position in the list. The scores are returned as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 3*item) * (bins - 3*item)\\n reward = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty + reward\\n \\n return scores\",\n \"objective\": 0.03642,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and adjusts the scores based on the bin's position in the list with a scaling factor. It also incorporates a variable penalty based on the item size and its relationship with the bin capacities, aiming to minimize the number of used bins by assigning items to bins with higher scores. Additionally, it applies a reward term for bins with rest capacity less than or equal to half of the maximum capacity, to encourage efficient utilization of larger bins, and introduces a logarithmic term to further adjust the scores based on their position in the list. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 3*item) * (bins - 3*item)\\n variable_penalty = (item / bins) - (item > 0.75 * bins) * 0.5\\n reward = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + np.log(positions + 1) + penalty + variable_penalty + reward\\n \\n return scores\",\n \"objective\": 0.03672,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and incorporates a variable penalty based on the item size and its relationship with the bin capacities. It also adjusts the scores based on the bin's position in the list with a scaling factor. The algorithm aims to minimize the number of used bins by assigning items to bins with higher scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins) - (item > 0.5 * bins) * 0.5\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity, and incorporating a variable penalty based on the item size and its relationship with the bin capacities, as well as adjusting the scores based on the bin's position in the list with a scaling factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions) * (item / bins)\\n \\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity. It also applies a penalty for bins that have a rest capacity greater than twice the item size, to encourage using smaller bins. Finally, it multiplies the scores by the square root of the remaining capacity, to further promote using smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = -bins + (bins == np.max(bins)) * item - (bins > 2*item) * item - np.sqrt(bins)\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by penalizing bins with larger remaining capacities, rewarding bins with smaller remaining capacities, incorporating a penalty term based on item size and its relationship with bin capacities, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n remaining_capacity = max_capacity - bins\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (1 - 0.5*positions) - np.log(positions+1) + np.exp(-item / bins)\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin by dividing the remaining capacity by the item size, applying a penalty for bins at maximum capacity, and adjusting the scores based on the bin's position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = (bins / item) - (bins == max_capacity) + (1 - 0.5 * positions)\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, incorporating a penalty for bins at maximum capacity, and adjusting the scores based on the proximity to the item size and the bin's position in the list, aiming to minimize the number of used bins. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to twice the item size, further encouraging the use of smaller bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + penalty\\n \\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) + ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, the position in the list of bins, the penalty term for bins with larger remaining capacities, and the reward term for bins with smaller remaining capacities. It also introduces a penalty term based on the item size to further fine-tune the scores, and applies a scaling factor to adjust the scores based on the proximity of the bins to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + reward - penalty + (bins % item) - (item % bins) + (bins / item)\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity, the proximity to the item size, and the logarithmic rank of the bins in the list, while also considering a penalty term for bins with larger remaining capacities and a reward term for bins with smaller remaining capacities. Additionally, it introduces a scaling factor to adjust the scores based on the proximity of the bins to the item size, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n rank = np.log(positions + 1)\\n\\n scores = ((max_capacity - bins) / (1 + proximity)) + reward - penalty + rank + (bins % item) - (item % bins) + (bins / item)\\n\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'My new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the inverse of the proximity to the item size squared, the logarithm of the remaining capacity, the square root of the position in the list of bins, and a penalty term that increases with the remaining capacity of the bin.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n rewards = 1 / ((proximity + 1) ** 2)\\n penalties = np.log(max_capacity) - np.log(bins)\\n \\n scores = ratio * rewards - penalties + np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the remaining capacity to the item size ratio raised to a power, the proximity to the item size, the position in the list of bins, and also adds a penalty term for bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = ((bins / item)**2) / (1 + proximity) + np.sqrt(positions) - np.log(max_capacity / bins)\\n\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the inverse of the proximity to the item size, the logarithm of the remaining capacity, and the position in the list of bins, while also incorporating a reward term for bins with smaller remaining capacities and penalizing bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n rewards = 1 / (proximity + 1)\\n penalties = np.log(max_capacity) - np.log(bins)\\n \\n scores = ratio * rewards - penalties + np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on a combination of the bin's remaining capacity, the item size, and a logarithmic term, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 1.5*item) * (bins - 1.5*item) # Adjusted penalty term\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 2*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.02465,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm prioritizes bins with larger remaining capacities, penalizes bins at or near maximum capacity, and adjusts the scores based on their position in the list. It also incorporates a penalty term based on the item size and its relationship with the bin capacities, aiming to minimize the number of used bins. Additionally, it introduces a logarithmic term to further modify the scores based on their position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins. It applies a penalty for bins at maximum capacity, includes a penalty-term for bins with a rest capacity greater than or equal to the item size, and introduces a new term that evaluates the ratio of the remaining capacity to the item size, aiming to encourage the use of smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n ratio = bins / item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty + ratio\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins. It applies a penalty for bins at maximum capacity and includes a logarithmic term to further adjust the scores based on their position. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to the item size, aiming to encourage the use of smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and adjusts the scores based on the bin's position in the list with a scaling factor. It also introduces a penalty-term for bins with a rest capacity greater than or equal to twice the item size, aiming to encourage the use of smaller bins. Additionally, it applies a reward term for bins with rest capacity less than or equal to half of the maximum capacity, to encourage efficient utilization of larger bins, and incorporates a logarithmic term to further adjust the scores based on their position in the list. The scores are returned as a Numpy array with a modification to the penalty term, where bins with rest capacity greater than or equal to twice the item size are penalized by the squared difference from the item size divided by the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * ((item - bins)**2 / bins)\\n reward = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty + reward\\n \\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: My modified algorithm calculates the scores for the bins based on their remaining capacities and their distances from the item size, penalizes bins with capacities closer to the maximum capacity, and adjusts the scores based on their position in the list, while also incorporating a penalty term based on the item size and its relationship with the bin capacities, and introducing a logarithmic term to further modify the scores based on their position.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 0.75*max_capacity) * (bins - 0.75*max_capacity)\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm aims to optimize bin utilization by assigning items to bins with the highest scores, considering the remaining capacity, proximity to the item size, and position in the list of bins, while also introducing a variable penalty term based on the item size and its relationship with the bin capacities and a reward term for bins with rest capacity less than or equal to half of the maximum capacity, ultimately reducing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = (bins >= 2*item) * ((item - bins)**2 / bins)\\n reward = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + (2 - 0.5*positions) + np.log(positions + 1) + penalty + reward\\n \\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of factors including the remaining capacity, proximity to the item size, position in the list, and a penalty term for bins with larger remaining capacities, aiming to minimize the number of used bins. Additionally, it introduces a reward term for bins with smaller remaining capacities and utilizes a logarithmic term to adjust the scores based on their position in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) - np.log(positions + 1) + ratio\\n \\n return scores\",\n \"objective\": 0.03119,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm prioritizes bins with smaller remaining capacities, penalizes bins at or near maximum capacity, and adjusts the scores based on their position in the list. It also incorporates a penalty term based on the item size and its relationship with the bin capacities, aiming to minimize the number of used bins. Additionally, it introduces a logarithmic term to further modify the scores based on their position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = (bins >= 2*item) * (bins - 2*item)\\n scores = (max_capacity - bins) / (1 + np.abs(bins - item)) - (1 - 0.5*np.arange(len(bins))) + np.log(1 + np.arange(len(bins))) + penalty\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, the position in the list of bins, and the penalty term for bins with larger remaining capacities. Besides, it also includes a reward term for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) + ratio - np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, and the position in the list of bins, while also incorporating a penalty term for bins with larger remaining capacities and rewarding bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = (np.log(max_capacity) - np.log(bins)) / (1 + proximity) + ratio - np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, incorporates a variable penalty based on the item size and its relationship with the bin capacities, and adjusts the scores based on the bin's position in the list with a scaling factor. It also applies a reward term for bins with rest capacity less than or equal to half of the maximum capacity, to encourage efficient utilization of larger bins, and introduces a logarithmic term to further adjust the scores based on their position in the list. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * (bins - 2*item)\\n variable_penalty = (item / bins) - (item > 0.8 * bins) * 0.2\\n reward = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.7*positions) + np.log(positions + 1) + penalty + variable_penalty + reward\\n \\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, penalizing bins at maximum capacity and adjusting the scores based on the proximity to the item size and the bin's position in the list. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - positions + penalty\\n \\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, incorporating a penalty for bins at maximum capacity, and adjusting the scores based on the proximity to the item size and the bin's position in the list, aiming to minimize the number of used bins. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to twice the item size, further encouraging the use of smaller bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + penalty\\n \\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to calculate the scores for each bin based on the bin's remaining capacity, the item size, the square root of the distance to the item size, an exponential decay factor, and penalty terms based on the item size and bin position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n distance = np.abs(bins - item)\\n penalty = (bins >= 1.2*item) * (bins - 1.2*item)\\n decay_factor = 0.9\\n \\n scores = ((max_capacity - bins) / (1 + np.sqrt(distance))**decay_factor) - (1 - 3*positions) + np.log(positions + 1) + penalty\\n \\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) + ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the bin's remaining capacity, the item size, and a modified penalty term, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 1.2*item) * (bins - 1.2*item) # Modified penalty term\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the ratio of the remaining capacity to the item size, the proximity to the item size, the position in the list of bins, the penalty term for bins with larger remaining capacities, and the reward term for bins with smaller remaining capacities. It also introduces a penalty term based on the item size to further fine-tune the scores, and applies a scaling factor to adjust the scores based on the proximity of the bins to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) + reward - penalty + (bins % item) - (item % bins) + (bins / item)\\n \\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity, the proximity to the item size, and the logarithmic rank of the bins in the list, while also considering a penalty term for bins with larger remaining capacities and a reward term for bins with smaller remaining capacities. Additionally, it introduces a scaling factor to adjust the scores based on the proximity of the bins to the item size, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n rank = np.log(positions + 1)\\n\\n scores = ((max_capacity - bins) / (1 + proximity)) + reward - penalty + rank + (bins % item) - (item % bins) + (bins / item)\\n\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"'My new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the inverse of the proximity to the item size squared, the logarithm of the remaining capacity, the square root of the position in the list of bins, and a penalty term that increases with the remaining capacity of the bin.'\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n rewards = 1 / ((proximity + 1) ** 2)\\n penalties = np.log(max_capacity) - np.log(bins)\\n \\n scores = ratio * rewards - penalties + np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item) / np.max(bins)\\n ratio = bins / item / np.max(bins)\\n positions = np.arange(len(bins))\\n \\n scores = ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the remaining capacity to the item size ratio raised to a power, the proximity to the item size, the position in the list of bins, and also adds a penalty term for bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = ((bins / item)**2) / (1 + proximity) + np.sqrt(positions) - np.log(max_capacity / bins)\\n\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the inverse of the proximity to the item size, the logarithm of the remaining capacity, and the position in the list of bins, while also incorporating a reward term for bins with smaller remaining capacities and penalizing bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n rewards = 1 / (proximity + 1)\\n penalties = np.log(max_capacity) - np.log(bins)\\n \\n scores = ratio * rewards - penalties + np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio of the remaining capacity to the item size, the inverse of the proximity to the item size, the logarithm of the remaining capacity, the position in the list of bins, and an additional penalization term for bins with remaining capacities smaller than a specified threshold, while also incorporating a reward term for bins with smaller remaining capacities and penalizing bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n rewards = 1 / (proximity + 1)\\n penalties = np.log(max_capacity) - np.log(bins)\\n threshold = 0.5 * max_capacity # Specify the threshold for smaller remaining capacities\\n small_cap_penalties = np.where(bins <= threshold, -1/(bins + 1), 0) # Penalize bins with remaining capacities smaller than the threshold\\n \\n scores = ratio * rewards - penalties + small_cap_penalties + np.sqrt(positions)\\n \\n return scores\",\n \"objective\": 0.02234,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on a combination of the bin's remaining capacity, the item size, and a logarithmic term, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 1.5*item) * (bins - 1.5*item) # Adjusted penalty term\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 2*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.02465,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm prioritizes bins with larger remaining capacities, penalizes bins at or near maximum capacity, and adjusts the scores based on their position in the list. It also incorporates a penalty term based on the item size and its relationship with the bin capacities, aiming to minimize the number of used bins. Additionally, it introduces a logarithmic term to further modify the scores based on their position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the proximity to the item size, and the logarithm of the ratio of remaining capacity to the item size, while considering penalty terms for bins at maximum capacity and for bins with rest capacity greater than or equal to the item size, with an additional term that evaluates the position of the bins in the list, in order to optimize the assignment of the item to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n ratio = np.log(bins / item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty + ratio\\n \\n return scores\",\n \"objective\": 0.02616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins. It applies a penalty for bins at maximum capacity, includes a penalty-term for bins with a rest capacity greater than or equal to the item size, and introduces a new term that evaluates the ratio of the remaining capacity to the item size, aiming to encourage the use of smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n ratio = bins / item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty + ratio\\n \\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, penalizing bins at maximum capacity with a larger penalty, and adjusts the scores based on the bin's position in the list with a scaling factor. It also introduces a penalty-term for bins with a rest capacity greater than or equal to three times the item size, aiming to encourage the use of smaller bins. Additionally, it applies a reward term for bins with rest capacity less than or equal to half of the maximum capacity, to encourage efficient utilization of larger bins, and incorporates a logarithmic term to further adjust the scores based on their position in the list. The scores are returned as a Numpy array with a modification to the penalty term, where bins with rest capacity greater than or equal to three times the item size are penalized by the squared difference from the item size divided by the rest capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 3*item) * ((item - bins)**2 / bins)\\n reward = (bins <= 0.5*max_capacity) * (0.5*max_capacity - bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.35*positions) - np.log(positions + 1) + penalty + reward\\n \\n return scores\",\n \"objective\": 0.02656,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity, the proximity to the item size, and their position in the list of bins. It applies a penalty for bins at maximum capacity and includes a logarithmic term to further adjust the scores based on their position. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to the item size, aiming to encourage the use of smaller bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= item) * (bins - item)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) - np.log(positions + 1) + penalty\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, incorporates a penalty for bins at maximum capacity, adjusts the scores based on the proximity to the item size and the bin's position in the list, and introduces a penalty term for bins with a rest capacity greater than or equal to three times the item size, further encouraging the use of smaller bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins), dtype=np.float64)\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 3*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - (1/len(bins))*positions) + penalty\\n \\n return scores\",\n \"objective\": 0.02827,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item) / item # Modified proximity component\\n penalty = 0.1 # Simplified penalty component\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) / np.sqrt(max_capacity) # Modified reward component\\n \\n positions = np.arange(len(bins))\\n scores = 0.2*(reward / (1 + proximity)) + 0.5*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins # Simplified penalty component\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the bin's remaining capacity, the item size, and a modified penalty term, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = (1 - np.exp(-ratio)) * (bins >= item) * (bins - item) # Modified penalty term\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 2*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = bins # Simplified penalty component\\n reward = max_capacity - bins # Simplified reward component\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, penalizing bins at maximum capacity and adjusting the scores based on the proximity to the item size and the bin's position in the list. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - positions + penalty\\n \\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, incorporating a penalty for bins at maximum capacity, and adjusting the scores based on the proximity to the item size and the bin's position in the list, aiming to minimize the number of used bins. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to twice the item size, further encouraging the use of smaller bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + penalty\\n \\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins # Simplified penalty component\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the item size, and a combination of penalty and reward terms, with the aim of minimizing the number of used bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = (bins - item) * (bins >= item)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - positions + penalty + reward\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to calculate the scores for each bin based on the bin's remaining capacity, the item size, the square root of the distance to the item size, an exponential decay factor, and penalty terms based on the item size and bin position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n distance = np.abs(bins - item)\\n penalty = (bins >= 1.2*item) * (bins - 1.2*item)\\n decay_factor = 0.9\\n \\n scores = ((max_capacity - bins) / (1 + np.sqrt(distance))**decay_factor) - (1 - 3*positions) + np.log(positions + 1) + penalty\\n \\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted exponential sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.3*ratio - 0.1*np.exp(-positions) + 0.25*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = (penalty + reward) / (1 + proximity) + ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the bin's remaining capacity, the item size, and a modified penalty term, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 1.2*item) * (bins - 1.2*item) # Modified penalty term\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and penalty terms for bins with larger remaining capacities and rewards for bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = ratio - np.sqrt(positions) + (bins % item) - (item % bins)\\n \\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity to the item size ratio, the proximity to the item size, and the position in the list of bins. It also includes a penalty term for bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n scores = ((bins / item) ** 2) / (1 + proximity) + np.sqrt(positions)\\n scores -= np.log(np.where(bins > item, max_capacity / bins, 1))\\n \\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity, the proximity to the item size, and the logarithmic rank of the bins in the list, while also considering a penalty term for bins with larger remaining capacities and a reward term for bins with smaller remaining capacities. Additionally, it introduces a scaling factor to adjust the scores based on the proximity of the bins to the item size, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n\\n proximity = np.abs(bins - item)\\n penalty = np.log(avg_capacity) - np.log(bins)\\n reward = np.sqrt(avg_capacity) - np.sqrt(bins)\\n rank = np.log(np.arange(len(bins)) + 1)\\n\\n scores = ((avg_capacity - bins) / (1 + proximity)) + reward - penalty + rank + (bins % item) - (item % bins) + (bins / item)\\n\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the remaining capacity to the item size ratio, the proximity to the item size, the position in the list of bins, and a new parameter called \\\"efficiency\\\" which measures the efficiency of the bin in terms of utilizing its capacity. It also includes a penalty term for bins with larger remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n \\n efficiency = (bins / item) / (1 + np.sqrt(positions))\\n \\n scores = ((bins / item) ** 2) / (1 + proximity) + np.sqrt(positions) + efficiency\\n scores -= np.log(np.where(bins > item, max_capacity / bins, 1))\\n \\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity, the proximity to the item size, and the logarithmic rank of the bins in the list, while also considering a penalty term for bins with larger remaining capacities and a reward term for bins with smaller remaining capacities. Additionally, it introduces a scaling factor to adjust the scores based on the proximity of the bins to the item size, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n rank = np.log(positions + 1)\\n\\n scores = ((max_capacity - bins) / (1 + proximity)) + reward - penalty + rank + (bins % item) - (item % bins) + (bins / item)\\n\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list of bins, and additional modifiers such as penalty/reward terms and proximity to the item size, while introducing a customized combination of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.4*(penalty + reward) / (1 + proximity) - 0.3*np.sqrt(positions) + 0.6*(bins % item) - 0.7*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list of bins, and additional modifiers such as penalty/reward terms and proximity to the item size, while introducing a customized combination of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) - 0.2*np.sqrt(positions) + 0.5*(bins % item) - 0.6*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"My new algorithm aims to assign scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, and its position in the list of bins, while also considering additional penalty/reward terms, and it introduces a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.3*(penalty + reward) / (1 + proximity) + 0.6*ratio - 0.2*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, their proximity, and the position of the bin in the list. It also introduces additional penalty and reward terms, and uses a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = np.log(max_capacity) - np.log(bins)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.25*(penalty + reward) / (1 + proximity) + 0.5*(bins / item) - 0.15*np.sqrt(positions) + 0.1*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a new nonlinear transformation to determine the scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = np.log(1 + bins) # New penalty component, log transformation\\n reward = np.sqrt(max_capacity) - np.sqrt(bins) # Existing reward component\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins) + 0.3*penalty # New nonlinear combination\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item) / item # Modified proximity component\\n penalty = 0.1 # Simplified penalty component\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) / np.sqrt(max_capacity) # Modified reward component\\n \\n positions = np.arange(len(bins))\\n scores = 0.2*(reward / (1 + proximity)) + 0.5*(bins / item) - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, penalizes bins at maximum capacity, and adjusts the scores based on the proximity to the item size and the position of the bin in the list. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation, while also considering the distance of the bin from the average capacity of all bins, taking into account the standard deviation of the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n avg_capacity = np.mean(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n distance_from_avg = np.abs(bins - avg_capacity)\\n std_dev = np.std(bins)\\n\\n scores = ((max_capacity - bins) / (1 + proximity)) - (positions * std_dev) + penalty - distance_from_avg\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = -np.log(bins)\\n reward = np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to minimize the number of used bins by promoting the use of smaller bins, efficient allocation, and considering penalty/reward terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n \\n positions = np.arange(len(bins))\\n penalty = (bins % item) * (bins >= item)\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) * (bins < max_capacity)\\n\\n scores = 0.2 * (max_capacity - bins) / (1 + proximity) + 0.3 * ratio - 0.1 * positions + 0.2 * penalty - 0.3 * reward\\n \\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and the ratio of the bin's capacity to the item size, while also considering the bin's position in the list and applying penalty/reward terms to determine the scores. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n \\n positions = np.arange(len(bins))\\n penalty = (bins % item) * (bins >= item)\\n reward = (np.sqrt(max_capacity) - np.sqrt(bins)) * (bins < max_capacity)\\n\\n scores = (max_capacity - bins) / (1 + proximity) + ratio - positions * 0.1 + penalty - reward\\n \\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins # Simplified penalty component\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the bin's remaining capacity, the item size, and a modified penalty term, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n penalty = (1 - np.exp(-ratio)) * (bins >= item) * (bins - item) # Modified penalty term\\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 2*positions) + np.log(positions + 1) + penalty\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, proximity to the item size, and the bin's position in the list, while also incorporating a penalty/reward term. It aims to minimize the number of used bins and promote efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n capacity_ratio = bins / max_capacity\\n positions = np.arange(len(bins))\\n penalty = (bins >= 2 * item) * item\\n reward = np.exp(-(bins / max_capacity) ** 2)\\n\\n scores = ((max_capacity - bins) / (1 + proximity)) + 0.7 * capacity_ratio - positions + penalty + reward\\n \\n return scores\",\n \"objective\": 0.01308,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = bins # Simplified penalty component\\n reward = max_capacity - bins # Simplified reward component\\n \\n scores = 0.2*(reward / (1 + proximity)) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, penalizing bins at maximum capacity and adjusting the scores based on the proximity to the item size and the bin's position in the list. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - positions + penalty\\n \\n return scores\",\n \"objective\": 0.01328,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, incorporating a penalty for bins at maximum capacity, and adjusting the scores based on the proximity to the item size and the bin's position in the list, aiming to minimize the number of used bins. Additionally, it introduces a penalty-term for bins with a rest capacity greater than or equal to twice the item size, further encouraging the use of smaller bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (1 - 0.5*positions) + penalty\\n \\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins # Simplified penalty component\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.2*(penalty + reward) / (1 + proximity) + 0.5*ratio - 0.1*np.sqrt(positions) + 0.2*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity, penalizing bins at maximum capacity, and adjusting the scores based on the proximity to the item size, the bin's position in the list, and an additional factor that considers the product of the bin capacity and the item size. It aims to minimize the number of used bins by promoting the use of smaller bins and efficient allocation, while also considering the relative size of the item and bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n proximity = np.abs(bins - item)\\n penalty = (bins >= 2*item) * item\\n product = bins * item\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - (positions - np.sqrt(positions)) + penalty - np.log(1 + product)\\n \\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the item size, and a combination of penalty and reward terms, with the aim of minimizing the number of used bins and promoting efficient allocation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = (bins - item) * (bins >= item)\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - positions + penalty + reward\\n \\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to calculate the scores for each bin based on the bin's remaining capacity, the item size, the square root of the distance to the item size, an exponential decay factor, and penalty terms based on the item size and bin position.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n positions = np.arange(len(bins))\\n distance = np.abs(bins - item)\\n penalty = np.maximum(0, bins - 1.2*item)\\n decay_factor = 0.9\\n \\n scores = ((max_capacity - bins) / (1 + np.sqrt(distance))**decay_factor) - (1 - 3*positions) + np.log(positions + 1) + penalty\\n \\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, its proximity to the item size, its position in the list of bins, and additional penalty/reward terms, while introducing a weighted exponential sum of these factors to determine the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n ratio = bins / item\\n positions = np.arange(len(bins))\\n penalty = max_capacity - bins\\n reward = np.sqrt(max_capacity) - np.sqrt(bins)\\n \\n scores = 0.15*(penalty + reward) / (1 + proximity) + 0.3*ratio - 0.1*np.exp(-positions) + 0.25*(bins % item) - 0.4*(item % bins)\\n \\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the item size, and a combination of penalty and reward terms, with the aim of minimizing the number of used bins and promoting efficient allocation. The main algorithm parameters are 'item' and 'bins'.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n proximity = np.abs(bins - item)\\n positions = np.arange(len(bins))\\n penalty = (bins - item) * (bins >= item)\\n reward = np.exp(-(bins/max_capacity)**2)\\n \\n scores = ((max_capacity - bins) / (1 + proximity)) - positions + penalty + reward\\n \\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula, taking into account both the remaining capacity and the current usage count of the bin. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - curr_bin) / (np.sqrt(curr_bin) * (np.log(curr_bin + 1)**2 + 1))\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item)**2 + constant_factor * np.power(order, 2)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n order = np.arange(len(bins)) + 1\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = (bins - item)**2 + constant_factor * np.power(order, 2)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, bins with an available capacity less than half the maximum capacity have a score of 1, and bins with an available capacity greater than half the maximum capacity have a score equal to the available capacity minus half the maximum capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n half_max_capacity = max_capacity / 2\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n elif curr_bin < half_max_capacity:\\n scores[i] = 1\\n else:\\n scores[i] = (curr_bin - half_max_capacity) / max_capacity\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on their remaining capacities and the size of the current item, using a combination of exponential and logarithmic functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins/item) - np.log(np.log(np.log(bins + item))) + constant_factor * np.power(np.arange(len(bins)) + 1, 2)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of exponential and power functions, as well as the logarithm of the bin's current capacity, with a constant factor adjusting the promotion of earlier bins, and the square of the index of the bin within the bins array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins/item) - np.power(np.log(bins + item), 2) + constant_factor * np.power(np.arange(len(bins)), 2)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of exponential and logarithmic functions, as well as the inverse of the bin's current capacity, with a constant factor adjusting the promotion of earlier bins, and the squared value of the index of the bin within the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins/item) - np.log(np.log(np.log(bins + item))) + constant_factor / (bins + 1) + np.power(np.arange(len(bins)), 2)\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, bins with an available capacity less than half the maximum capacity have a score of 1, and bins with an available capacity greater than half the maximum capacity have a score equal to the square root of twice the available capacity minus the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n half_max_capacity = max_capacity / 2\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n elif curr_bin < half_max_capacity:\\n scores[i] = 1\\n else:\\n scores[i] = sqrt(2 * curr_bin - max_capacity)\\n \\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the bin's current capacity, the exponential function of the item divided by the bin, and the square of the index of the bin within the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) + np.exp(item/bins) - np.power(np.arange(len(bins)), 2)\\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, bins with an available capacity less than half the maximum capacity have a score of 1, and bins with an available capacity greater than half the maximum capacity have a score equal to the square root of the available capacity minus half the maximum capacity.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n half_max_capacity = max_capacity / 2\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n elif curr_bin < half_max_capacity:\\n scores[i] = 1\\n else:\\n scores[i] = sqrt(curr_bin - half_max_capacity)\\n \\n return scores\",\n \"objective\": 0.04377,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the sum of the bin's capacity and the item size, multiplied by the square root of the sum of the bin's capacity and the item size, plus the natural logarithm of the number of times the bin has been used, squared.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins / ((bins + item) * np.sqrt(bins + item)) + np.log(np.arange(len(bins))+1)**2\\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on its remaining capacity, where bins with larger remaining capacity than the item size have a score of 1 divided by the bin's remaining capacity minus the item size plus 1, and bins with smaller remaining capacity than the item size have a score of the bin's remaining capacity divided by the item size plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n item_size = np.full_like(bins, item)\\n remaining_capacities = bins - item_size\\n \\n scores[remaining_capacities >= item] = 1 / (remaining_capacities[remaining_capacities >= item] - item + 1)\\n scores[remaining_capacities < item] = remaining_capacities[remaining_capacities < item] / (item + 1)\\n \\n return scores\",\n \"objective\": 0.0484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the bin's current capacity divided by the item size, plus the natural logarithm of the bin's capacity divided by item size, subtracting the square root of the bin's usage count.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = bins / item + np.log(bins / item) - np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.0487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n bin_capacities = np.where(bins != item, bins, 0)\\n\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of exponential and power functions, as well as the logarithm of the bin's current capacity, with a constant factor adjusting the promotion of earlier bins, and the cubic value of the index of the bin within the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins/item) - np.power(np.log(bins + item), 3) + constant_factor * np.power(np.arange(len(bins)), 3)\\n return scores\",\n \"objective\": 0.05483,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * np.sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithmic function of the item size, the square root of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + np.sqrt(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the natural logarithm of the item size, the square root of the reciprocal of the difference between the bin's remaining capacity and the item size squared, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/((bins - item)**2)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithmic function of the item size, the square root of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + np.sqrt(1 / ((bins - item)**2)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the logarithm of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size divided by the bin's capacity, the reciprocal cube root of the difference between the bin's capacity and the item size, and a constant factor that penalizes later bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired penalization of later bins\\n scores = (bins / (np.log(item / bins))) + (1 / np.cbrt(bins - item)) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, the logarithmic function of the bin's capacity divided by the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1 / (bins - item)) + np.log(bins) / item + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the square root of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 1.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / (np.log(item)) + (1 / np.sqrt(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, and a polynomial function involving the reciprocal of the difference between the bin's capacity and the item size, the square of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + 1 / ((bins - item) * item**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, a logarithmic function of the bin's capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the logarithm of the item size, the square root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / log(item) + item ** 0.5 + constant_factor * reciprocal + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * np.sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, the square of the reciprocal of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n \\n scores = bins / np.log(item) + constant_factor * np.exp(1/(bins - item)) + (1/item**2) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, a polynomial function involving the reciprocal of the difference between the bin's remaining capacity and the item size, the square of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + 1 / ((bins - item)**2 * item**2) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.9.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size plus the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.7.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the inverse of the difference between the bin's remaining capacity and the item size, the square root of the reciprocal of the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n \\n scores = bins / np.log(item) + (1 / (bins - item)) + np.sqrt(1 / item) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the logarithm of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size divided by the bin's capacity, the reciprocal cube root of the difference between the bin's capacity and the item size, and a constant factor that penalizes later bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired penalization of later bins\\n scores = (bins / (np.log(item / bins))) + (1 / np.cbrt(bins - item)) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, the logarithmic function of the bin's capacity divided by the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1 / (bins - item)) + np.log(bins) / item + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = (bins / np.log(item)) + ((1 / (bins - item))**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the logarithm of the bin's capacity, the square root of the reciprocal of the difference between the bin's remaining capacity and the item size squared, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8, and an additional term is added that is the product of the bin's remaining capacity and the reciprocal of the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.sqrt(item) + np.log(bins) + np.sqrt(1/((bins - item)**2)) + constant_factor * np.arange(len(bins)) + (bins * (1/item))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm assigns scores to each bin based on the product of the bin's remaining capacity and the square root of the reciprocal of the item size, the logarithm function of the bin's remaining capacity, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is set to 0.5.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = (bins * sqrt(1/item)) + np.log(bins) + (1/np.sqrt((bins - item)**2)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the inverse of the difference between the bin's remaining capacity and the item size squared, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + 1 / (bins - item)**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.9.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size plus the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.7.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.8, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the inverse of the difference between the bin's remaining capacity and the item size squared, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.sqrt(item) + 1 / (bins - item)**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the logarithm of the item size, the cubic root of the item size, and the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n \\n scores = bins / sqrt(log(item)) + (item**0.3333) + (1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size divided by the bin's capacity, the reciprocal cube root of the difference between the bin's capacity and the item size, and a constant factor that penalizes later bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired penalization of later bins\\n scores = (bins / (np.log(item / bins))) + (1 / np.cbrt(bins - item)) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, the logarithmic function of the bin's capacity divided by the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1 / (bins - item)) + np.log(bins) / item + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.6.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.9.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size plus the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.7.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the inverse of the difference between the bin's remaining capacity and the item size squared, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.sqrt(item) + 1 / (bins - item)**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the logarithm of the item size, the cubic root of the item size, and the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n \\n scores = bins / sqrt(log(item)) + (item**0.3333) + (1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size divided by the bin's capacity, the reciprocal cube root of the difference between the bin's capacity and the item size, and a constant factor that penalizes later bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired penalization of later bins\\n scores = (bins / (np.log(item / bins))) + (1 / np.cbrt(bins - item)) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, the logarithmic function of the bin's capacity divided by the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1 / (bins - item)) + np.log(bins) / item + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, but also incorporates the logarithm of the bin's remaining capacity and the logarithm of the item size, all in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins)) + np.log(bins) + np.log(item)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the fourth power of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.sqrt(item) + (1 / (bins - item))**4 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the inverse of the difference between the bin's remaining capacity and the item size squared, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.sqrt(item) + 1 / (bins - item)**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the square root of the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.9.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n scores = bins / (np.sqrt(np.log(item))) + (1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size divided by the bin's capacity, the reciprocal cube root of the difference between the bin's capacity and the item size, and a constant factor that penalizes later bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired penalization of later bins\\n scores = (bins / (np.log(item / bins))) + (1 / np.cbrt(bins - item)) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, the square root of the bin's capacity, and a constant factor that promotes earlier bins, to minimize the number of used bins. In this new algorithm, the constant factor is set to 1.2.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjusted constant factor\\n scores = (bins / np.log(item)) + (1 / (bins - item)) + np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modified version of the previous algorithm. It assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. The constant factor that promotes earlier bins is set to 0.8, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, but also incorporates the logarithm of the bin's remaining capacity and the logarithm of the item size, all in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins)) + np.log(bins) + np.log(item)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the fourth power of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.sqrt(item) + (1 / (bins - item))**4 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins and incorporates the square root of the bin's remaining capacity, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / (np.log(item)) + (1 / (bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the square root of the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.9.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n scores = bins / (np.sqrt(np.log(item))) + (1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size divided by the bin's capacity, the reciprocal cube root of the difference between the bin's capacity and the item size, and a constant factor that penalizes later bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired penalization of later bins\\n scores = (bins / (np.log(item / bins))) + (1 / np.cbrt(bins - item)) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size. A logarithmic scaling is also applied to the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item) + 1) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modified version of the previous algorithm. It assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. The constant factor that promotes earlier bins is set to 0.8, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the cube root of the item size, the reciprocal of the cube root of the difference between the bin's remaining capacity and the item size, and a larger constant factor that penalizes earlier bins, in order to further minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.75\\n scores = bins / np.cbrt(item) + 1 / np.cbrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the fourth power of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.sqrt(item) + (1 / (bins - item))**4 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins and incorporates the square root of the bin's remaining capacity, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / (np.log(item)) + (1 / (bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, the square root of the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, the constant factor is set to 0.6, and an additional term is added that is the square root of the bin's remaining capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + np.arange(len(bins)) + np.sqrt(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the square root of the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.9.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjusted constant factor\\n scores = bins / (np.sqrt(np.log(item))) + (1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size. A logarithmic scaling is also applied to the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item) + 1) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modified version of the previous algorithm. It assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. The constant factor that promotes earlier bins is set to 0.8, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.75.\\n\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.75 # Adjusted constant factor\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the exponentiation of the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.exp((1 / (bins - item))**2) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / sqrt(item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size raised to the power of 4/5, and the inverse of the difference between the bin's capacity and the item size raised to the power of 3/2. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size raised to the power of 7/8. Lastly, a logarithmic scaling is applied to the scores by taking the natural logarithm of the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item)**(4/5) + 1) + np.sqrt(1/((bins - item)**(3/2))) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)**(7/8)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins and incorporates the square root of the bin's remaining capacity, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / (np.log(item)) + (1 / (bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.6.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item)) + np.arange(len(bins)) * 0.6\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item))**2 + np.arange(len(bins))*0.5\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size. A logarithmic scaling is also applied to the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item) + 1) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modified version of the previous algorithm. It assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. The constant factor that promotes earlier bins is set to 0.8, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.75.\\n\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.75 # Adjusted constant factor\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the exponentiation of the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.exp((1 / (bins - item))**2) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / sqrt(item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size raised to the power of 4/5, and the inverse of the difference between the bin's capacity and the item size raised to the power of 3/2. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size raised to the power of 7/8. Lastly, a logarithmic scaling is applied to the scores by taking the natural logarithm of the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item)**(4/5) + 1) + np.sqrt(1/((bins - item)**(3/2))) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)**(7/8)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins and incorporates the square root of the bin's remaining capacity, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / (np.log(item)) + (1 / (bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.6.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item)) + np.arange(len(bins)) * 0.6\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item))**2 + np.arange(len(bins))*0.5\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size. A logarithmic scaling is also applied to the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item) + 1) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modified version of the previous algorithm. It assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. The constant factor that promotes earlier bins is set to 0.8, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.75.\\n\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.75 # Adjusted constant factor\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the exponentiation of the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.exp((1 / (bins - item))**2) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / sqrt(item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size raised to the power of 4/5, and the inverse of the difference between the bin's capacity and the item size raised to the power of 3/2. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size raised to the power of 7/8. Lastly, a logarithmic scaling is applied to the scores by taking the natural logarithm of the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item)**(4/5) + 1) + np.sqrt(1/((bins - item)**(3/2))) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)**(7/8)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins and incorporates the square root of the bin's remaining capacity, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / (np.log(item)) + (1 / (bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.6.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item)) + np.arange(len(bins)) * 0.6\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item))**2 + np.arange(len(bins))*0.5\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size. A logarithmic scaling is also applied to the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item) + 1) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, the square root of the bin's capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins / (bins - item + 1)) + np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and penalizing bins that have a smaller rest capacity, in order to minimize the number of used bins. The score for each bin is calculated based on the item size divided by the difference between the bin's rest capacity and the item size, plus a penalty term that is multiplied by the ratio of the bin's rest capacity to the maximum rest capacity among all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = ((item / (bins[bins != max_capacity] - item + 1)) + 0.5 * bins[bins != max_capacity] / max_capacity)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the logarithmic function of the bin's remaining capacity, the difference between the bin's remaining capacity and the size of the item, and a constant factor that promotes earlier bins, while also accounting for the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins) / np.log(bins - item + 1) + constant_factor * np.arange(len(bins)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula, taking into account both the remaining capacity and the current usage count of the bin. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - curr_bin) / (np.sqrt(curr_bin) * (np.log(curr_bin + 1)**2 + 1))\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula, taking into account both the remaining capacity and the current usage count of the bin. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - curr_bin) / (curr_bin + 1)\\n \\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the bin's current capacity divided by the item size, plus the number of times the bin has been used, to promote performance and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = (bins - item)**2 + constant_factor * np.power(order, 2)\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n order = np.arange(len(bins)) + 1\\n constant_factor = 0.5\\n scores = (bins - item)**2 + constant_factor * np.power(order, 2)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, bins with an available capacity less than half the maximum capacity have a score of 1, and bins with an available capacity greater than half the maximum capacity have a score equal to the available capacity minus half the maximum capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n half_max_capacity = max_capacity / 2\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n elif curr_bin < half_max_capacity:\\n scores[i] = 1\\n else:\\n scores[i] = (curr_bin - half_max_capacity) / max_capacity\\n \\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to the bins based on their remaining capacities and the size of the current item, using a combination of exponential and logarithmic functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins/item) - np.log(np.log(np.log(bins + item))) + constant_factor * np.power(np.arange(len(bins)) + 1, 2)\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of exponential and power functions, as well as the logarithm of the bin's current capacity, with a constant factor adjusting the promotion of earlier bins, and the square of the index of the bin within the bins array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins/item) - np.power(np.log(bins + item), 2) + constant_factor * np.power(np.arange(len(bins)), 2)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, taking into account both the current usage count of the bin and the item size, using a combination of exponentiation, logarithm, and power functions, as well as a constant factor to adjust the promotion of earlier bins and the index of the bin within the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 2.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins/item) - np.power(np.log(bins + item), 2) + constant_factor * np.power(np.arange(len(bins)), 2)\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of logarithmic and exponential functions, the reciprocal of the bin's current capacity, a constant factor that adjusts the promotion of earlier bins, and the square of the index of the bin within the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.exp(bins / item) - np.log(np.log(bins + item)) + constant_factor / (bins + 1) + np.power(np.arange(len(bins)), 2)\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, bins with an available capacity less than half the maximum capacity have a score of 1, and bins with an available capacity greater than half the maximum capacity have a score equal to the square root of twice the available capacity minus the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n half_max_capacity = max_capacity / 2\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n elif curr_bin < half_max_capacity:\\n scores[i] = 1\\n else:\\n scores[i] = sqrt(2 * curr_bin - max_capacity)\\n \\n return scores\",\n \"objective\": 0.04347,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the bin's current capacity, the exponential function of the item divided by the bin, and the square of the index of the bin within the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) + (item/bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, bins with an available capacity less than half the maximum capacity have a score of 1, and bins with an available capacity greater than half the maximum capacity have a score equal to the square root of the available capacity minus half the maximum capacity.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n half_max_capacity = max_capacity / 2\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n elif curr_bin < half_max_capacity:\\n scores[i] = 1\\n else:\\n scores[i] = sqrt(curr_bin - half_max_capacity)\\n \\n return scores\",\n \"objective\": 0.04377,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.6.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modified version of the previous algorithm. It assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. The constant factor that promotes earlier bins is set to 0.8, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.75.\\n\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.75 # Adjusted constant factor\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the exponentiation of the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + np.exp((1 / (bins - item))**2) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / sqrt(item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size raised to the power of 4/5, and the inverse of the difference between the bin's capacity and the item size raised to the power of 3/2. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size raised to the power of 7/8. Lastly, a logarithmic scaling is applied to the scores by taking the natural logarithm of the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item)**(4/5) + 1) + np.sqrt(1/((bins - item)**(3/2))) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)**(7/8)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the item size, the reciprocal of the square root of the difference between the bin's remaining capacity and the item size, and a constant factor that penalizes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5\\n scores = bins / np.sqrt(item) + 1 / np.sqrt(bins - item) - constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins and incorporates the square root of the bin's remaining capacity, to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.7.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / (np.log(item)) + (1 / (bins - item)) + constant_factor * np.arange(len(bins)) + np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1 / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, the squared reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**2 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the inverse of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.6.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item)) + np.arange(len(bins)) * 0.6\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the square root of the item size, the square of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(item) + (1 / (bins - item))**2 + np.arange(len(bins))*0.5\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithm of the item size, the cube of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes later bins, in order to minimize the number of used bins. In this new algorithm, the constant factor is set to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + (1 / (bins - item))**3 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the cube root of the item size, the inverse of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / pow(item, 1/3) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm of the item size, and the square root of the inverse of the difference between the bin's capacity and the item size. A constant factor of 0.8 is applied to each bin, and an additional term is added, which is the square root of the bin's remaining capacity divided by twice the item size. A logarithmic scaling is also applied to the scores to promote earlier bins effectively.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n scores = bins / (np.log(item) + 1) + np.sqrt(1/(bins - item)) + 0.8*np.arange(len(bins)) + np.sqrt(bins) / (2*item)\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithm function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, the square root of the bin's capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins / (bins - item + 1)) + np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = np.power(1/(bins-item), 2) + np.log(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.power(1/(bins-item), 2) + np.log(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.sqrt(item) * np.exp(1 / (bins - item + 1)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item + 1) + 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin and penalizing bins that have a smaller rest capacity, in order to minimize the number of used bins. The score for each bin is calculated based on the item size divided by the difference between the bin's rest capacity and the item size, plus a penalty term that is multiplied by the ratio of the bin's rest capacity to the maximum rest capacity among all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = ((item / (bins[bins != max_capacity] - item + 1)) + 0.5 * bins[bins != max_capacity] / max_capacity)\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm computes a score for each bin based on a modified formula that takes into account both the logarithm of the rest capacity and the square root of the item size, with an additional term that linearly increases with the index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.log(bins - item + 1) + np.sqrt(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nimport numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins) / np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins) / np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm computes the score for each bin by dividing the item size by the square root of the difference between the bin's remaining capacity and the item size, and then multiplying it by the logarithm of the bin's remaining capacity, plus a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = (item / np.sqrt(bins - item + 1)) * np.log(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the logarithmic function of the bin's remaining capacity, the difference between the bin's remaining capacity and the size of the item, and a constant factor that promotes earlier bins, while also accounting for the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins) / np.log(bins - item + 1) + constant_factor * np.arange(len(bins)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = bins - (bins - item)**2 + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - (bins - item)**2\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula, taking into account both the remaining capacity and the current usage count of the bin. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - curr_bin) / (np.sqrt(curr_bin) * (np.log(curr_bin + 1)**2 + 1))\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a polynomial function of the current usage count and the bin's index, with the goal of minimizing the number of used bins and optimizing performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins - item + 1) + np.arange(len(bins))**3 - np.log((np.arange(len(bins)) + 1) * np.log(bins - item + 1))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula, taking into account both the remaining capacity and the current usage count of the bin. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n curr_bin = bins[i]\\n if curr_bin == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - curr_bin) / (curr_bin + 1)\\n \\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * np.power(1/(bins-item), 2) + ratio * np.log(bins) + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n \\n # Simplified normalization of ratio array\\n ratio = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n \\n scores = (1 - ratio) * (1/(bins-item)) + np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a weighted sum of the difference between the bin's remaining capacity and the size of the item, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins - item + 1) + np.log(bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log10(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithm function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a weighted sum of the difference between the bin's remaining capacity and the size of the item, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins - item + 1) + constant_factor * np.arange(len(bins)) + np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size and adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log1p(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root of the item size, the logarithmic function of the difference between the bin's capacity and the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / (np.sqrt(item) * np.log(bins - item + 1) * np.exp(1 / (bins - item + 1))) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, the square root of the bin's capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins / (bins - item + 1)) + np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, the square root of the bin's capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins / (bins - item + 1)) + np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = np.power(1/(bins-item), 2) + np.log(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.power(1/(bins-item), 2) + np.log(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the exponential function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.exp(bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + 2*np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin. The score for each bin is calculated based on the item size divided by the difference between the bin's rest capacity and the item size, minus a penalty term that is multiplied by the ratio of the bin's rest capacity to the maximum rest capacity among all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins != max_capacity] = ((item / (bins[bins != max_capacity] - item + 1)) - 0.5 * bins[bins != max_capacity] / max_capacity)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.sqrt(item) * np.exp(1 / (bins - item + 1)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins < bins.max()] = item / (bins[bins < bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n scores = (bins - item) / np.log(bins - item + 1) + constant_factor * np.sqrt(item) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root function of the item size, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are as follows:\\n1. Calculate the reciprocal of the difference between the bin's capacity and the item size.\\n2. Calculate the scores using the formula: scores = (bins - item) / np.sqrt(item) + np.log(1/reciprocal) + constant_factor * np.arange(len(bins))\\n3. Return the calculated scores as output.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / np.sqrt(item) + np.log(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * np.power(1/(bins-item), 2) + ratio * np.log(bins) + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n \\n # Simplified normalization of ratio array\\n ratio = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n \\n scores = (1 - ratio) * (1/(bins-item)) + np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the square root of the item size, the logarithmic function of the difference between the bin's capacity and the item size, and a weighted sum of the difference between the bin's remaining capacity and the size of the item, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n weighted_sum = (item / (bins - item + 1)) + (np.log(bins - item + 1) / np.log(bins)) + (constant_factor * np.arange(len(bins)))\\n scores = bins / (np.sqrt(item) * np.log(bins - item + 1) * weighted_sum)\\n return scores\",\n \"objective\": 0.02515,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the the scores for each bin based on their rest capacities, but in addition to the existing formula, it will also consider the square root of the item size and subtract a constant multiple of the bin index from the score.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins)) - sqrt(item) - 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, the square root of the sum of the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size, adding the square root of the sum of the bin's capacity and the item size, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log1p(bins - item + 1) + np.sqrt(bins + item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a weighted sum of the difference between the bin's remaining capacity and the size of the item, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins - item + 1) + np.log(bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log10(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03099,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * np.power(1/(bins-item), 2) + ratio * np.log(bins) + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / (np.max(bins) - np.min(bins))\\n \\n scores = (1 - ratio) * (1/(bins-item)) + np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.03149,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a weighted sum of the difference between the bin's remaining capacity and the size of the item, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins - item + 1) + constant_factor * np.arange(len(bins)) + np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size and adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log1p(bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0321,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Instead of assigning scores based on specific mathematical functions, my new algorithm will assign scores to each bin based on a combination of factors including the bin's remaining capacity, the square root of the bin's capacity, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = (bins / np.sqrt(bins)) + (np.log(1 / (bins + 1 - item))) + (constant_factor * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.0325,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size and adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log1p(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0329,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root of the item size, the logarithmic function of the difference between the bin's capacity and the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / (np.sqrt(item) * np.log(bins - item + 1) * np.exp(1 / (bins - item + 1))) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins - item + 1) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root of the bin's capacity, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.sqrt(bins) + np.log(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03461,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.linspace(0, 1, len(bins)) # Adjust the weights linearly based on the number of bins\\n scores = bins / np.log(bins - item + 1) + weights * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n scores = (bins - item) / np.log(bins - item + 1) + constant_factor * np.sqrt(item) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, and a weighted sum of the square root of the sum of the bin's capacity and the item size, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 2.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = (bins / np.log1p(bins - item + 1)) + ((np.sqrt(bins + item) + np.log(bins - item + 1)) * np.log1p(bins))\\n scores += constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * (1/(bins-item)) + constant_factor * bins + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n scores = (1 - ratio) * (1/(bins-item)) + bins + np.arange(len(bins)) \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root function of the item size, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are as follows:\\n1. Calculate the reciprocal of the difference between the bin's capacity and the item size.\\n2. Calculate the scores using the formula: scores = (bins - item) / np.sqrt(item) + np.log(1/reciprocal) + constant_factor * np.arange(len(bins))\\n3. Return the calculated scores as output.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / np.sqrt(item) + np.log(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins. The aim is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size squared, the square root of the reciprocal of the difference between the bin's capacity and the item size squared, the reciprocal of the difference between the bin's capacity and three times the item size squared, and a constant factor that promotes earlier bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size squared, adding the square root of the reciprocal of the difference between the bin's capacity and the item size squared, adding the reciprocal of the difference between the bin's capacity and three times the item size squared, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item**2) + np.sqrt(1/((bins - item)**2)) + 1/((bins - 3*item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root of the logarithmic function of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.sqrt(np.log1p(bins - item + 1)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * np.power(1/(bins-item), 2) + ratio * np.log(bins) + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n total_capacity = np.sum(bins)\\n \\n # Simplified normalization of ratio array\\n ratio = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n \\n scores = (1 - ratio) * (1/(bins-item)) + np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the sum of the bin's capacity and the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the sum of the bin's capacity and the item size, adding the reciprocal of the difference between the bin's remaining capacity and the item size, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 2.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins + item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the square root of the item size, the logarithmic function of the difference between the bin's capacity and the item size, and a weighted sum of the difference between the bin's remaining capacity and the size of the item, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n weighted_sum = (item / (bins - item + 1)) + (np.log(bins - item + 1) / np.log(bins)) + (constant_factor * np.arange(len(bins)))\\n scores = bins / (np.sqrt(item) * np.log(bins - item + 1) * weighted_sum)\\n return scores\",\n \"objective\": 0.02515,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, the square root of the sum of the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size, adding the square root of the sum of the bin's capacity and the item size, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log1p(bins - item + 1) + np.sqrt(bins + item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the the scores for each bin based on their rest capacities, but in addition to the existing formula, it will also consider the square root of the item size and subtract a constant multiple of the bin index from the score.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins)) - sqrt(item) - 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, the square root of the sum of the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size, adding the square root of the sum of the bin's capacity and the item size, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log1p(bins - item + 1) + np.sqrt(bins + item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square root of the sum of the bin's capacity and the item size, the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size, adding the square root of the sum of the bin's capacity and the item size, adding the reciprocal of the difference between the bin's remaining capacity and the item size, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log1p(bins - item + 1) + np.sqrt(bins + item) + 1 / (bins - item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.02968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the difference between the bin's capacity and the item size, and a weighted sum of the difference between the bin's remaining capacity and the size of the item, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.log(bins - item + 1) + np.log(bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n scores = bins / np.log(np.sqrt(bins - item + 1)) + np.sqrt(bins) + 1.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n scores = (bins - item) / np.log(bins - item + 1) + constant_factor * np.sqrt(item) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the square root of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 1.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / (np.log(item)) + (1 / np.sqrt(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, and a weighted sum of the square root of the sum of the bin's capacity and the item size, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 2.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = (bins / np.log1p(bins - item + 1)) + ((np.sqrt(bins + item) + np.log(bins - item + 1)) * np.log1p(bins))\\n scores += constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.3 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size squared, the square root of the reciprocal of the difference between the bin's capacity and the item size squared, the reciprocal of the difference between the bin's capacity and three times the item size squared, and a constant factor that promotes earlier bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size squared, adding the square root of the reciprocal of the difference between the bin's capacity and the item size squared, adding the reciprocal of the difference between the bin's capacity and three times the item size squared, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1/(np.sqrt(bins - item)) + 1/(bins - 3*item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * (1/(bins-item)) + constant_factor * bins + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n scores = (1 - ratio) * (1/(bins-item)) + bins + np.arange(len(bins)) \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root function of the item size, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are as follows:\\n1. Calculate the reciprocal of the difference between the bin's capacity and the item size.\\n2. Calculate the scores using the formula: scores = (bins - item) / np.sqrt(item) + np.log(1/reciprocal) + constant_factor * np.arange(len(bins))\\n3. Return the calculated scores as output.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / np.sqrt(item) + np.log(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins. The aim is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on a combination of factors including the bin capacity, the item size, and a constant factor, and then returns the scores for assignment.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 2.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size squared, the square root of the reciprocal of the difference between the bin's capacity and the item size squared, the reciprocal of the difference between the bin's capacity and three times the item size squared, and a constant factor that promotes earlier bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size squared, adding the square root of the reciprocal of the difference between the bin's capacity and the item size squared, adding the reciprocal of the difference between the bin's capacity and three times the item size squared, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item**2) + np.sqrt(1/((bins - item)**2)) + 1/((bins - 3*item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n reciprocal_diff = 1 / (bins - item)\\n sqrt_reciprocal_diff = np.sqrt(reciprocal_diff)\\n log_reciprocal_diff = np.log(reciprocal_diff)\\n scores = bins + constant_factor * np.arange(len(bins)) + sqrt_reciprocal_diff + log_reciprocal_diff\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root of the logarithmic function of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.sqrt(np.log1p(bins - item + 1)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01861,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm calculates the scores for each bin based on their remaining capacities, the logarithmic function of the sum of the bin's capacity and the item size, the reciprocal function of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins + item)) + (1 / (bins - item)) + (1.5 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n scores = (bins - item) / np.log(bins - item + 1) + constant_factor * np.sqrt(item) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + 2 * log(item) + constant_factor * np.exp(2 * reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the square root of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 1.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / (np.log(item)) + (1 / np.sqrt(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, and a weighted sum of the square root of the sum of the bin's capacity and the item size, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 2.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = (bins / np.log1p(bins - item + 1)) + ((np.sqrt(bins + item) + np.log(bins - item + 1)) * np.log1p(bins))\\n scores += constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.3 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm computes the scores for each bin based on the bin's remaining capacity, the logarithmic function of the item size, the square root of the sum of the bin's capacity and the item size, and a constant factor that promotes later bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of later bins\\n scores = (bins / np.log1p(bins - item + 1)) + ((np.sqrt(bins + item) + np.log(bins - item + 1)) * np.log1p(bins))\\n scores += constant_factor * np.arange(len(bins), 0, -1)\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the cube root of the reciprocal of the difference between the bin's capacity and the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a variable factor that promotes earlier bins.\",\n \"code\": \"import numpy as np\\nfrom math import pow, exp\\n\\ndef score(item, bins):\\n factor = 1.2 # Adjusted factor\\n reciprocal_diff = 1 / (bins - item)\\n cube_reciprocal_diff = np.cbrt(reciprocal_diff)\\n exp_reciprocal_diff = np.exp(reciprocal_diff)\\n scores = bins + factor * np.arange(len(bins)) + cube_reciprocal_diff + exp_reciprocal_diff\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size squared, the square root of the reciprocal of the difference between the bin's capacity and the item size squared, the reciprocal of the difference between the bin's capacity and three times the item size squared, and a constant factor that promotes earlier bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size squared, adding the square root of the reciprocal of the difference between the bin's capacity and the item size squared, adding the reciprocal of the difference between the bin's capacity and three times the item size squared, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n scores = bins / np.log(item) + 1/(np.sqrt(bins - item)) + 1/(bins - 3*item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square root of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.5 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + np.sqrt(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * (1/(bins-item)) + constant_factor * bins + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = (bins - np.min(bins)) / (np.max(bins) - np.min(bins))\\n scores = (1 - ratio) * (1/(bins-item)) + bins + np.arange(len(bins)) \\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores based on a modified formula that takes into account the bin capacity, the remaining capacity of each bin, and a constant factor. The main steps of the algorithm are as follows:\\n1. Calculate the ratio between the remaining capacity of each bin and the total capacity of all bins.\\n2. Calculate the scores using the formula: scores = (1 - ratio) * (1/(bins-item)) + constant_factor * bins + constant_factor * np.arange(len(bins))\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n avg_rest_capacity = np.mean(rest_capacities)\\n ratio = rest_capacities / avg_rest_capacity\\n scores = (1 - ratio) * (1/rest_capacities) + bins + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size squared, the square root of the reciprocal of the difference between the bin's capacity and the item size squared, the reciprocal of the difference between the bin's capacity and three times the item size squared, and a constant factor that promotes earlier bins. The main steps are to calculate the scores by dividing the remaining capacity of each bin by the logarithmic function of the item size squared, adding the square root of the reciprocal of the difference between the bin's capacity and the item size squared, adding the reciprocal of the difference between the bin's capacity and three times the item size squared, and finally adding a constant factor multiplied by the index of each bin in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + 1/(np.sqrt(bins - item)) + 1/(bins - 3*item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the square root function of the item size, the logarithmic function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. The main steps are as follows:\\n1. Calculate the reciprocal of the difference between the bin's capacity and the item size.\\n2. Calculate the scores using the formula: scores = (bins - item) / np.sqrt(item) + np.log(1/reciprocal) + constant_factor * np.arange(len(bins))\\n3. Return the calculated scores as output.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / np.sqrt(item) + np.log(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.5.\\n\",\n \"code\": \"import numpy as np\\nfrom math import exp, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.exp(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n scores = (bins - item) / np.log(bins - item + 1) + 0.5 * np.sqrt(item) + 0.5 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef score(item, bins):\\n constant_factor = 1.2 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = np.log(bins + 1 / (item - bins)) * np.sqrt(bins) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the square root of the item size, the logarithmic function of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / sqrt(item) + log(item) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity divided by the logarithmic function of the item size, the square root of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.6 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + np.sqrt(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's remaining capacity and various mathematical functions involving the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\nfrom math import log, sqrt\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n scores = (bins - item) / np.log(bins - item + 1) + constant_factor * np.sqrt(item) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1 # Simplified to remove overfitting\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the inverse of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.7 and multiply the score with the logarithmic function of the bin's capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1 / (bins - item)) + constant_factor * np.arange(len(bins)) + np.log(bins) * np.log(bins) / item\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the logarithm of the item size, the cubic root of the item size, the exponential function of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log, exp\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / log(item) + item ** (1/3) + constant_factor * np.exp(reciprocal) + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, the logarithmic function of the bin's capacity divided by the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1 / (bins - item)) + np.log(bins) / item + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the logarithmic function of the item size, the reciprocal of the square root of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 1.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / (np.log(item)) + (1 / np.sqrt(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the natural logarithm function of the bin's capacity, and a polynomial function involving the reciprocal of the difference between the bin's capacity and the item size, the square of the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.7 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + 1 / ((bins - item) * item**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio between the bin's remaining capacity and the logarithm of the item size, the square root of the item size, the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.5 # Adjust this constant factor based on desired promotion of earlier bins\\n \\n reciprocal = 1 / (bins - item)\\n scores = (bins - item) / log(item) + item ** 0.5 + constant_factor * reciprocal + constant_factor * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, the bin's logarithmic function of capacity, the reciprocal of the difference between the bin's capacity and the item size squared, and a constant factor that promotes earlier bins. In this new algorithm, the constant factor is adjusted to 0.8.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + 1/((bins - item)**2) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the product of the reciprocal of the difference between the bin's remaining capacity and the item size, the square root of the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.9 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(bins) + (1/(bins - item)) * sqrt(item) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, and a weighted sum of the square root of the sum of the bin's capacity and the item size, the logarithmic function of the bin's remaining capacity, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_factor = 2.0 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = (bins / np.log1p(bins - item + 1)) + ((np.sqrt(bins + item) + np.log(bins - item + 1)) * np.log1p(bins))\\n scores += constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8.\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithmic function of the bin's capacity, the square root of the reciprocal of the difference between the bin's capacity and the item size, and a constant factor that promotes earlier bins, with the aim of minimizing the number of used bins. In this new algorithm, I will adjust the constant factor to 0.8 and add a new term that is the logarithmic function of the bin's capacity divided by the item size.\",\n \"code\": \"import numpy as np\\nfrom math import sqrt, log\\n\\ndef score(item, bins):\\n constant_factor = 0.8 # Adjusted constant factor\\n scores = bins / np.log(bins) + np.sqrt(1/(bins - item)) + constant_factor * np.arange(len(bins)) + np.log(bins) / item\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's remaining capacity, the logarithmic function of the item size, the square of the reciprocal of the difference between the bin's remaining capacity and the item size, and a constant factor that promotes earlier bins, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\nfrom math import log\\n\\ndef score(item, bins):\\n constant_factor = 1.3 # Adjust this constant factor based on desired promotion of earlier bins\\n scores = bins / np.log(item) + np.square(1 / (bins - item)) + constant_factor * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # small value to avoid division by zero and to prevent sensitivity to small changes\\n scores = (bins + epsilon) / (bins - item + epsilon) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(bins - item + 1e-6)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a power-based function with a base of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n scores[bins != max_capacity] = 2 ** (1 - np.log2(bins[bins != max_capacity] / max_capacity))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and the priority is given to the bin with the closest rest capacity to the item size, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[:] = 1 / (np.abs(bins[:] - item) + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins and the index position of the bin within the sorted array of bins in ascending order. It also considers the ratio of the rest capacity of each bin to the item size, penalizes bins with higher rest capacities, and returns the scores for each bin.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n ratios = sorted_bins.astype(float) / item\\n max_capacity = max(sorted_bins)\\n ratios[sorted_bins == max_capacity] = 0\\n positions = np.argsort(bins)\\n position_scores = np.exp(-positions.astype(float))\\n\\n penalized_ratios = ratios * position_scores\\n scores = penalized_ratios / max(penalized_ratios)\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, where the score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaled_bins = bins / item\\n scores = scaled_bins + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic function.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = np.log(max_capacity - bins[bins != max_capacity] + 1)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic function.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones_like(bins)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All algorithms calculate a score for each bin based on its capacity and other factors such as position or usage count.\\n\\nNew Algorithm: The new algorithm assigns a score to each bin based on a combination of the remaining capacity, the cumulative sum of capacities in descending order, the position of the bin within the sorted array of bins in ascending order, and the number of times the bin has been used.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n cumulative_sum = np.cumsum(sorted_bins[::-1])[::-1]\\n max_capacity = sorted_bins[-1]\\n usage_count = np.arange(len(bins))\\n scores = np.maximum(0, cumulative_sum - bins) / (np.sqrt(max_capacity - item)) + usage_count\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on a weighted combination of the rest capacity of the bin, the cumulative sum of capacities in ascending order, and the square root of the item size, where higher rest capacities, lower cumulative sum, and larger item sizes are penalized and result in lower scores.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n cumulative_sum = np.cumsum(sorted_bins)\\n scores = (bins / (cumulative_sum + np.sqrt(item))) - item\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, where the score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins/item)**0.5 + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, where the score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (\\n (bins / item) ** 0.5 * np.log(bins) +\\n np.arange(len(bins))\\n )\\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the rest capacity of each bin to minimize the number of used bins.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a weighted combination of the rest capacity of the bin, the cumulative sum of capacities in descending order, and the square root of the item size, where higher rest capacities, higher cumulative sum, and larger item sizes are penalized and result in lower scores.\\n\\nImplementation in Python:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n cumulative_sum = np.cumsum(sorted_bins)\\n scores = (bins / (cumulative_sum + np.sqrt(item))) ** 2\\n return scores\",\n \"objective\": 0.04447,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin taking into account the rest capacity, cumulative sum, item size, and usage history of the bin, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n cumulative_sum = np.cumsum(sorted_bins)\\n num_used_bins = np.arange(len(bins))\\n scores = (bins / (cumulative_sum + np.sqrt(item) + np.log(1 + num_used_bins))) ** 2\\n return scores\",\n \"objective\": 0.04457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio between the current item size and the remaining capacity of the bin, taking into account the positions of the bins within the sorted array of bins in descending order and the number of times each bin has been used, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Sort the bins array in descending order\\n sorted_bins = np.sort(bins)[::-1]\\n \\n # Calculate the ratio of item size to the remaining capacity of each bin\\n ratios = item / (sorted_bins - item)\\n \\n # Set the score for bins with equal remaining capacity to the maximum capacity as 0\\n ratios[sorted_bins == max(sorted_bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios by the position in the sorted array and adding the number of times the bin has been used\\n scores = ratios * np.arange(len(bins)) + np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04628,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, which is the difference between the maximum capacity of the bins and the average capacity of the bins, squared multiplied by a factor of 5, divided by the number of items already assigned to bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n weight = 5 * ((bins.max() - bins.mean()) ** 2) / num_items\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, num_items + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity multiplied by the exponential of the bin's capacity minus the item size, all raised to the power of the square root of the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, and divided by the number of times the bin has been used plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins - item))**np.sqrt(np.log(bins / (bins - item)) / (np.arange(1, len(bins) + 1) + 1))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the product of the current capacity of the bin divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the natural logarithm of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) / (item - bins) * (np.sqrt(np.arange(1, len(bins) + 1)) + bins / item))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on the bin's current capacity and other factors, such as the number of times the bin has been used and the item's size.}\\n\\n{My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the exponential of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) * np.exp(bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, and the square root of the bin's current capacity divided by the number of times the bin has been used, all raised to the power of the bin's current capacity minus the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) + np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the item size, the square root of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and multiplied by the exponential of the bin's current capacity divided by the bin's capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / item) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item) * np.exp(bins / (bins - item))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the exponential of the bin's current capacity divided by the bin's capacity minus the item size, and the square root of the bin's current capacity divided by the number of times the bin has been used, all raised to the power of the bin's current capacity minus the item size. \\n\\nHere is the implementation of the new algorithm in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) + np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(1) New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the square root of the ratio of the bin's current capacity to the item size, and the logarithm of the bin's current capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the natural logarithm of the bin's capacity minus the item size, and then multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins.\\n\\nImplementation in Python:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.mean()) / np.std(bins) # Weight modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins\\n scores = np.sqrt(bins / item) + np.log(bins - item) * (bins / np.arange(1, len(bins) + 1)) ** (np.log(bins - item)) * weight\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity, and multiplied by the logarithm of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item)) * np.log(bins)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (item - bins) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the exponential of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the square root of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all multiplied by the exponential of the bin's current capacity divided by the bin's capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item) + np.log(bins / (bins - item)) * np.exp(bins / (bins - item))\\n return scores\",\n \"objective\": 0.01258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size minus the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.sqrt(bins / np.arange(1,len(bins)+1))**(bins - item - np.log(item))\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the square root of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and multiplied by the exponential of the bin's current capacity divided by the item size.\\n\\nNew implementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(bins - item) * np.exp(bins / item)\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the square root of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity divided by the item size, squared and multiplied by a weight value.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.sqrt(bins / (bins - item)) + (bins / np.arange(1, len(bins) + 1))**(bins / item)**2 * weight\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, which is the difference between the maximum capacity of the bins and the average capacity of the bins, squared multiplied by a factor of 5, divided by the number of items already assigned to bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n weight = 5 * ((bins.max() - bins.mean()) ** 2) / num_items\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, num_items + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The score for each bin is calculated based on the current capacity of the bin, the number of times the bin has been used, and the item size.\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the square root of the bin's current capacity divided by the number of items already assigned to bins and the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (np.log(bins / (bins - item)) * (bins / np.arange(1, len(bins) + 1))**(bins - item) * np.exp(bins / item)) * (np.sqrt(bins / num_items) + np.log(bins / (bins - item)))**(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity multiplied by the exponential of the bin's capacity minus the item size, all raised to the power of the square root of the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, and divided by the number of times the bin has been used plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins - item))**np.sqrt(np.log(bins / (bins - item)) / (np.arange(1, len(bins) + 1) + 1))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the product of the current capacity of the bin divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the natural logarithm of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) / (item - bins) * (np.sqrt(np.arange(1, len(bins) + 1)) + bins / item))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on the bin's current capacity and other factors, such as the number of times the bin has been used and the item's size.}\\n\\n{My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the exponential of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) * np.exp(bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, and the square root of the bin's current capacity divided by the number of times the bin has been used, all raised to the power of the bin's current capacity minus the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + ((bins / np.arange(1, len(bins) + 1))**(bins - item) * 0.5) \\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, and the product of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the item size.\\\"\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) + ((bins / np.arange(1, len(bins) + 1))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the item size, the square root of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and multiplied by the exponential of the bin's current capacity divided by the bin's capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / item) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item) * np.exp(bins / (bins - item))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the exponential of the bin's current capacity divided by the bin's capacity minus the item size, and the square root of the bin's current capacity divided by the number of times the bin has been used, all raised to the power of the bin's current capacity minus the item size. \\n\\nHere is the implementation of the new algorithm in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) + np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(1) New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the square root of the ratio of the bin's current capacity to the item size, and the logarithm of the bin's current capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the natural logarithm of the bin's capacity minus the item size, and then multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins.\\n\\nImplementation in Python:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.mean()) / np.std(bins) # Weight modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins\\n scores = np.sqrt(bins / item) + np.log(bins - item) * (bins / np.arange(1, len(bins) + 1)) ** (np.log(bins - item)) * weight\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity, and multiplied by the logarithm of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item)) * np.log(bins)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (item - bins) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the exponential of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, which is the difference between the maximum capacity of the bins and the average capacity of the bins, squared multiplied by a factor of 5, divided by the number of items already assigned to bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n weight = 5 * ((bins.max() - bins.mean()) ** 2) / num_items\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, num_items + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the square root of the bin's current capacity divided by the number of items already assigned to bins and the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((np.sqrt(bins / num_items) + np.log(bins / (bins - item)))**(bins - item))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, added to the natural logarithm of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) + np.log(bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity multiplied by the exponential of the bin's capacity minus the item size, all raised to the power of the square root of the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, and divided by the number of times the bin has been used plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins - item))**np.sqrt(np.log(bins / (bins - item)) / (np.arange(1, len(bins) + 1) + 1))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the product of the current capacity of the bin divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the natural logarithm of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) / (item - bins) * (np.sqrt(np.arange(1, len(bins) + 1)) + bins / item))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on the bin's current capacity and other factors, such as the number of times the bin has been used and the item's size.}\\n\\n{My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the exponential of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) * np.exp(bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity plus the item size, and the logarithm of the exponential of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.log(np.exp(bins / np.arange(1,len(bins)+1)))**(bins - item)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size plus one.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**(bins - item + 1)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, and the product of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the item size.\\\"\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) + ((bins / np.arange(1, len(bins) + 1))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the item size, the square root of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and multiplied by the exponential of the bin's current capacity divided by the bin's capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / item) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item) * np.exp(bins / (bins - item))\\n return scores\",\n \"objective\": 0.01147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the exponential of the bin's current capacity divided by the bin's capacity minus the item size, and the square root of the bin's current capacity divided by the number of times the bin has been used, all raised to the power of the bin's current capacity minus the item size. \\n\\nHere is the implementation of the new algorithm in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) + np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(1) New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the square root of the ratio of the bin's current capacity to the item size, and the logarithm of the bin's current capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the natural logarithm of the bin's capacity minus the item size, and then multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins.\\n\\nImplementation in Python:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.mean()) / np.std(bins) # Weight modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins\\n scores = np.sqrt(bins / item) + np.log(bins - item) * (bins / np.arange(1, len(bins) + 1)) ** (np.log(bins - item)) * weight\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, which is the difference between the maximum capacity of the bins and the average capacity of the bins, squared multiplied by a factor of 5, divided by the number of items already assigned to bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n weight = 5 * ((bins.max() - bins.mean()) ** 2) / num_items\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, num_items + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the square root of the bin's current capacity divided by the number of items already assigned to bins and the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((np.sqrt(bins / num_items) + np.log(bins / (bins - item)))**(bins - item))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, added to the natural logarithm of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) + np.log(bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size added to the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + item / 100)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**np.sqrt(bins - item + 2)\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the cosines of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the natural logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and added to the bin's current capacity itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 + bins\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity multiplied by the exponential of the bin's capacity minus the item size, all raised to the power of the square root of the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, and divided by the number of times the bin has been used plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins - item))**np.sqrt(np.log(bins / (bins - item)) / (np.arange(1, len(bins) + 1) + 1))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the product of the current capacity of the bin divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the natural logarithm of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) / (item - bins) * (np.sqrt(np.arange(1, len(bins) + 1)) + bins / item))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on the bin's current capacity and other factors, such as the number of times the bin has been used and the item's size.}\\n\\n{My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the exponential of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) * np.exp(bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity plus the item size, and the logarithm of the exponential of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.log(np.exp(bins / np.arange(1,len(bins)+1)))**(bins - item)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size plus one.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**(bins - item + 1)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, and the product of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the item size.\\\"\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) + ((bins / np.arange(1, len(bins) + 1))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, which is the difference between the maximum capacity of the bins and the average capacity of the bins, squared multiplied by a factor of 5, divided by the number of items already assigned to bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n weight = 5 * ((bins.max() - bins.mean()) ** 2) / num_items\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, num_items + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the square root of the bin's current capacity divided by the number of items already assigned to bins and the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((np.sqrt(bins / num_items) + np.log(bins / (bins - item)))**(bins - item))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, added to the natural logarithm of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) + np.log(bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as follows: the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus two, multiplied by the square root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**np.sqrt(bins - item + 2) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size added to the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + item / 100)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is the calculation of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to a power. \\n\\nBased on this backbone idea, my new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one. \\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**np.sqrt(bins - item + 2)\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the cosines of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the natural logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and added to the bin's current capacity itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 + bins\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used. \\n\\nBased on this backbone idea, my new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's capacity minus the item size plus three. \\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item + 3))\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity multiplied by the exponential of the bin's capacity minus the item size, all raised to the power of the square root of the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, and divided by the number of times the bin has been used plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(bins - item))**np.sqrt(np.log(bins / (bins - item)) / (np.arange(1, len(bins) + 1) + 1))\\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the product of the current capacity of the bin divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the natural logarithm of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) / (item - bins) * (np.sqrt(np.arange(1, len(bins) + 1)) + bins / item))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on the bin's current capacity and other factors, such as the number of times the bin has been used and the item's size.}\\n\\n{My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the exponential of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) * np.exp(bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity plus the item size, and the logarithm of the exponential of the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.log(np.exp(bins / np.arange(1,len(bins)+1)))**(bins - item)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, which is the difference between the maximum capacity of the bins and the average capacity of the bins, squared multiplied by a factor of 5, divided by the number of items already assigned to bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n weight = 5 * ((bins.max() - bins.mean()) ** 2) / num_items\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, num_items + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the bin's current capacity divided by the sum of all bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_bin = np.sum(bins)\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * (bins / sum_bin)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the square root of the bin's current capacity divided by the number of items already assigned to bins and the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((np.sqrt(bins / num_items) + np.log(bins / (bins - item)))**(bins - item))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, added to the natural logarithm of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) + np.log(bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as follows: the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus two, multiplied by the square root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**np.sqrt(bins - item + 2) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size added to the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + item / 100)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score based on the relationship between the bin's current capacity and the bin's capacity minus the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by the exponential of the bin's current capacity plus the item size.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 * np.exp(bins + item)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and finally multiplied by the bin's current capacity divided by the item size plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) * (bins / (item + 1))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**np.sqrt(bins - item + 2)\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the cosines of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the natural logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and added to the bin's current capacity itself.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cos(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 + bins\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size divided by the natural logarithm of the bin's current capacity plus one, and finally multiplied by the natural logarithm of the bin's current capacity plus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item) / np.log(bins + item + 1)) * np.log(bins + item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the bin's current capacity divided by the sum of all bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_bin = np.sum(bins)\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * (bins / sum_bin)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the bin's current capacity divided by the number of items already assigned to bins, the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size, and the square root of the bin's current capacity divided by the item size.\\n\\nNew score function implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((bins / num_items + np.log(bins / (bins - item)))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the square root of the bin's current capacity divided by the number of items already assigned to bins and the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((np.sqrt(bins / num_items) + np.log(bins / (bins - item)))**(bins - item))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"def score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\\n\\n# New algorithm description:\\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n# New algorithm: \\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 2*math.sqrt(item))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, added to the natural logarithm of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) + np.log(bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as follows: the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus two, multiplied by the square root of the bin's remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**np.sqrt(bins - item + 2) * np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, and some additional factors related to the bin's usage history.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item / 100))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size added to the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + item / 100)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score based on the relationship between the bin's current capacity and the bin's capacity minus the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by the exponential of the bin's current capacity plus the item size.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 * np.exp(bins + item)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and finally multiplied by the bin's current capacity divided by the item size plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) * (bins / (item + 1))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1)\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**np.sqrt(bins - item + 2)\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item))\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size divided by the natural logarithm of the bin's current capacity plus one, and finally multiplied by the natural logarithm of the bin's current capacity plus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item) / np.log(bins + item + 1)) * np.log(bins + item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the bin's current capacity divided by the sum of all bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_bin = np.sum(bins)\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * (bins / sum_bin)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the bin's current capacity divided by the number of items already assigned to bins, the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size, and the square root of the bin's current capacity divided by the item size.\\n\\nNew score function implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((bins / num_items + np.log(bins / (bins - item)))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n regularization = 1e-8\\n scores = (bins / (bins - item + regularization)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(-item)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size multiplied by 2 subtracted from the denominator of the second fraction.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item * 2))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"def score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\\n\\n# New algorithm description:\\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n# New algorithm: \\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 2*math.sqrt(item))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, added to the natural logarithm of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) + np.log(bins)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1e-8)) * (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, and some additional factors related to the bin's usage history.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item / 100))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size added to the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + item / 100)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score based on the relationship between the bin's current capacity and the bin's capacity minus the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by the exponential of the bin's current capacity plus the item size.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 * np.exp(bins + item)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size subtracted from the denominator of the second fraction and multiplied by a constant factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - item * 0.1)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the logarithm of the bin's current capacity divided by the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * np.log((bins / item) + 1)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and finally multiplied by the bin's current capacity divided by the item size plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) * (bins / (item + 1))\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size divided by the natural logarithm of the bin's current capacity plus one, and finally multiplied by the natural logarithm of the bin's current capacity plus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item) / np.log(bins + item + 1)) * np.log(bins + item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the bin's current capacity divided by the sum of all bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_bin = np.sum(bins)\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * (bins / sum_bin)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the bin's current capacity divided by the number of items already assigned to bins, the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size, and the square root of the bin's current capacity divided by the item size.\\n\\nNew score function implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((bins / num_items + np.log(bins / (bins - item)))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n regularization = 1e-8\\n scores = (bins / (bins - item + regularization)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(-item)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size multiplied by 2 subtracted from the denominator of the second fraction.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item * 2))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"def score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\\n\\n# New algorithm description:\\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n# New algorithm: \\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 2*math.sqrt(item))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm description\\\":\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size.\\n\\nNew algorithm:\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1e-8)) * (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, and some additional factors related to the bin's usage history.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item / 100))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins - np.sqrt(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the square root of the item size added to the denominator of the second fraction.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (bins + np.sqrt(item))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score based on the relationship between the bin's current capacity and the bin's capacity minus the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by the exponential of the bin's current capacity plus the item size.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 * np.exp(bins + item)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size subtracted from the denominator of the second fraction and multiplied by a constant factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - item * 0.1)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the logarithm of the bin's current capacity divided by the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * np.log((bins / item) + 1)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size divided by the natural logarithm of the bin's current capacity plus one, and finally multiplied by the natural logarithm of the bin's current capacity plus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item) / np.log(bins + item + 1)) * np.log(bins + item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the bin's current capacity divided by the sum of all bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_bin = np.sum(bins)\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * (bins / sum_bin)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the bin's current capacity divided by the number of items already assigned to bins, the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size, and the square root of the bin's current capacity divided by the item size.\\n\\nNew score function implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((bins / num_items + np.log(bins / (bins - item)))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n regularization = 1e-8\\n scores = (bins / (bins - item + regularization)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(-item)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size multiplied by 2 subtracted from the denominator of the second fraction.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item * 2))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"def score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 1)\\n return scores\\n\\n# New algorithm description:\\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n# New algorithm: \\n# The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - np.sqrt(item) + 2*math.sqrt(item))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm description\\\":\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size.\\n\\nNew algorithm:\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1e-8)) * (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, and some additional factors related to the bin's usage history.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item / 100))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins - np.sqrt(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**((bins - item) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score based on the relationship between the bin's current capacity and the bin's capacity minus the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by the exponential of the bin's current capacity plus the item size.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 * np.exp(bins + item)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus the item size, but with an additional factor of the item size added to the denominator of the second fraction and multiplied by a constant factor of 0.2.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + item * 0.2)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size subtracted from the denominator of the second fraction and multiplied by a constant factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - item * 0.1)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the logarithm of the bin's current capacity divided by the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * np.log((bins / item) + 1)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the power of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.5\\n scores = np.power(bins, 1.5) / np.sqrt(bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the exponential function raised to the power of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0 * (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins / np.sqrt(bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the exponential function raised to the power of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n scores = np.exp(bins / np.sqrt(bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the score for each bin by taking the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used. Next, it assigns the item to the bin with the maximum score and updates the rest capacity of the bin accordingly. This process is repeated until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1e-6) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and the priority is given to the bin with the highest rest capacity, rather than the closest, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[:] = bins[:] / (np.abs(bins[:] - item) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt(bins - item + 1e-6)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new algorithm: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThe new algorithm assigns an item to the bin with the maximum score and adjusts the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + 1\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\n\\\"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant weight.\\\"\\n\\nNew code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.5\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a power-based function with a base of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n scores[bins != max_capacity] = 2 ** (1 - np.log2(bins[bins != max_capacity] / max_capacity))\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and the priority is given to the bin with the closest rest capacity to the item size, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[:] = 1 / (np.abs(bins[:] - item) + 1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins and the index position of the bin within the sorted array of bins in ascending order. It also considers the ratio of the rest capacity of each bin to the item size, penalizes bins with higher rest capacities, and returns the scores for each bin.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)\\n ratios = sorted_bins.astype(float) / item\\n max_capacity = max(sorted_bins)\\n ratios[sorted_bins == max_capacity] = 0\\n positions = np.argsort(bins)\\n position_scores = np.exp(-positions.astype(float))\\n\\n penalized_ratios = ratios * position_scores\\n scores = penalized_ratios / max(penalized_ratios)\\n \\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, where the score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaled_bins = bins / item\\n scores = scaled_bins + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on a weighted combination of the rest capacity of the bin, the cumulative sum of capacities in ascending order, and the square root of the item size, where higher rest capacities, lower cumulative sum, and larger item sizes are penalized and result in lower scores.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n cumulative_sum = np.cumsum(bins)\\n scores = (bins / (cumulative_sum + np.sqrt(item))) - item\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size divided by the natural logarithm of the bin's current capacity plus one, and finally multiplied by the natural logarithm of the bin's current capacity plus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item) / np.log(bins + item + 1)) * np.log(bins + item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the bin's current capacity divided by the sum of all bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sum_bin = np.sum(bins)\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * (bins / sum_bin)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, the exponential of the bin's current capacity divided by the item size, all multiplied by the sum of the bin's current capacity divided by the number of items already assigned to bins, the logarithm of the bin's capacity divided by the bin's current capacity minus the item size, all raised to the power of the bin's current capacity minus the item size, and the square root of the bin's current capacity divided by the item size.\\n\\nNew score function implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n scores = (bins / (bins - item)) * (bins / np.arange(1, num_items + 1))**(bins - item) * np.exp(bins / item) * ((bins / num_items + np.log(bins / (bins - item)))**(bins - item)) * np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n regularization = 1e-8\\n scores = (bins / (bins - item + regularization)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(-item)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, number of times it has been used, and the item size.\\n\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, divided by the logarithm of the bin's current capacity. \\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) / np.log(bins)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on its current capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the natural logarithm of the bin's current capacity divided by the bin's capacity plus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus one.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log((bins / (bins - item)) + item) * ((bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))) / (np.sqrt(bins) + 1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size divided by the square root of the bin's current capacity, all divided by the square root of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**((bins - item) / np.sqrt(bins)) / np.sqrt(bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm description\\\":\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size.\\n\\nNew algorithm:\\nThe new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1e-8)) * (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, and some additional factors related to the bin's usage history.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the item size subtracted from the denominator of the second fraction.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins + (item / 100))\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, divided by the bin's current capacity, and with an additional factor of the square root of the item size subtracted from the denominator of the second fraction.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (bins - np.sqrt(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, divided by the square root of the bin's current capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**((bins - item) / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Calculating a score based on the relationship between the bin's current capacity and the bin's capacity minus the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the sine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the logarithm of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by the exponential of the bin's current capacity plus the item size.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / (bins - item)) + np.log(bins / np.arange(1,len(bins)+1))**(bins - item)**2 * np.exp(bins + item)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity plus the item size, but with an additional factor of the item size added to the denominator of the second fraction and multiplied by a constant factor of 0.2.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) + item * 0.2)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size, all divided by the square root of the bin's current capacity, with an additional factor of the item size subtracted from the denominator of the second fraction and multiplied by a constant factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item)) / (np.sqrt(bins) - item * 0.1)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the square root of the bin's current capacity minus the item size, and added to the exponential of the bin's current capacity divided by the bin's capacity minus the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1, len(bins)+1))**(np.sqrt(bins - item)) + np.exp(bins / (bins - item + 1))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size plus one, multiplied by the logarithm of the bin's current capacity divided by the item size plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item) + 1) * np.log((bins / item) + 1)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = 1 / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by the inverse of the cosine of the bin's capacity, and then raised to the power of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = (np.log(bins) / np.sqrt(bins - item) + np.arange(len(bins)) * weight) ** (item / bins)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value and raised to the power of the item's size divided by the bin's capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = (np.log(bins) / (bins - item) + np.arange(len(bins)) * weight) ** (item / bins)\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity divided by the difference between the item size and the bin's capacity, multiplied by the logarithm of the bin's capacity plus the number of times the bin has been used, and raised to the power of the item's size divided by the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (item - bins) * np.log(bins) + np.arange(len(bins))) ** (item / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. However, in this modified version, an additional factor is introduced where the score is multiplied by a factor of the bin's current capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n max_capacity = np.max(bins)\\n scores = bins / np.sqrt(bins - item) * (bins / max_capacity) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential of the item's size divided by the bin's remaining capacity, multiplied by the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.exp(item / (bins - item)) * np.sqrt(np.arange(len(bins))) * weight\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the sine of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the cosine of the number of times the bin has been used, multiplied by a weight value of 1.7.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.7\\n scores = np.sin(bins / (bins - item)) + np.cos(np.arange(len(bins))) * weight\\n return scores\",\n \"objective\": 0.0335,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the power of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a constant weight.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.5\\n scores = np.power(bins, 1.5) / np.sqrt(bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the exponential function raised to the power of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0 * (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins / np.sqrt(bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning a score to each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The algorithm assigns a score to each bin based on the cumulative sum of the exponential function raised to the power of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, and then normalizes the scores.\\n\\nImplementation in Python:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / np.sqrt(bins - item) + np.arange(len(bins))) # Calculate the scores based on the provided formula\\n scores /= np.sum(scores) # Normalize the scores to maintain self-consistency\\n return scores\",\n \"objective\": 0.03652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the exponential function raised to the power of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n scores = np.exp(bins / np.sqrt(bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by the inverse of the sine of the bin's capacity.\\n\\nImplementation in Python:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins)) / np.sin(bins)\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the score for each bin by taking the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used. Next, it assigns the item to the bin with the maximum score and updates the rest capacity of the bin accordingly. This process is repeated until all items are assigned.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1e-6) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, and the priority is given to the bin with the highest rest capacity, rather than the closest, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[:] = bins[:] / (np.abs(bins[:] - item) + 1)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the log of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.exp(bins / item + np.sqrt(np.arange(1, len(bins) + 1))) ** (np.log(bins) / (item - bins)) * weight\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to compute a score for each bin based on its current capacity, the difference between the bin's capacity and the item size, the number of times the bin has been used, and a weight value.}\\n\\n{My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the square root of the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / (bins - item) ** 0.5 * np.log10(np.arange(1, len(bins) + 1)) ** 2 * weight\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = 1 / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by the inverse of the cosine of the bin's capacity, and then raised to the power of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = (np.log(bins) / np.sqrt(bins - item) + np.arange(len(bins)) * weight) ** (item / bins)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared and multiplied by a weight value.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins))**2 * weight\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins) / 2\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the item's size divided by the bin's remaining capacity, multiplied by the logarithm of the number of times the bin has been used plus one, and finally divided by the mean value of the differences between consecutive bins' capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.sqrt(item / (bins - item)) * np.log(np.arange(len(bins)) + 1) / weight\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / len(bins)\\n scores = np.log(bins) / (bins - item) * np.log10(np.arange(1, len(bins) + 1)) * weight ** np.sqrt(item / bins)\\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. However, the weight value is modified to be the square root of the difference between the maximum capacity of the bins and the average capacity of the bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = np.sqrt((bins.max() - bins.mean()) / len(bins))\\n scores = np.log(bins / (bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.02425,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's current capacity, plus the number of times the bin has been used, multiplied by a weight value and raised to the power of the item's size divided by the bin's capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = (np.sqrt(bins) / (bins - item) * np.log(bins) + np.arange(len(bins)) * weight) ** (item / bins)\\n return scores\",\n \"objective\": 0.02646,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity divided by the difference between the item size and the bin's capacity, multiplied by the logarithm of the bin's capacity plus the number of times the bin has been used, and raised to the power of the item's size divided by the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (item - bins) * np.log(bins) + np.arange(len(bins))) ** (item / np.sqrt(bins))\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the sine function of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the cosine of the bin's capacity plus the number of times the bin has been used, and raised to the power of the exponential function of the bin's current capacity divided by the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sin(bins / np.sqrt(bins - item)) + np.cos(bins + np.arange(len(bins))) ** np.exp(bins / item)\\n return scores\",\n \"objective\": 0.0323,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. However, in this modified version, an additional factor is introduced where the score is multiplied by a factor of the bin's current capacity divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n max_capacity = np.max(bins)\\n scores = bins / np.sqrt(bins - item) * (bins / max_capacity) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.0326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential of the item's size divided by the bin's remaining capacity, multiplied by the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.exp(item / (bins - item)) * np.sqrt(np.arange(len(bins))) * weight\\n return scores\",\n \"objective\": 0.0327,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the item's size and the inverse of the squared difference between the bin's remaining capacity and the item's size, multiplied by the square root of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = item * (1 / (bins - item)**2) * np.sqrt(np.arange(len(bins))) * weight\\n return scores\",\n \"objective\": 0.0334,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the log of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.exp(bins / item + np.sqrt(np.arange(1, len(bins) + 1))) ** (np.log(bins) / (item - bins)) * weight\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Each algorithm calculates the score for each bin based on the bin's current capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, squared, and then multiplied by a weight value.\\n\\nPython implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins) / 2\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins)))**2 * weight\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = 1 / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by the inverse of the cosine of the bin's capacity, and then raised to the power of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = (np.log(bins) / np.sqrt(bins - item) + np.arange(len(bins)) * weight) ** (item / bins)\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared and multiplied by a weight value.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins))**2 * weight\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size and the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square root of the difference between the maximum capacity of the bins and the minimum capacity of the bins, divided by the average capacity of the bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = np.sqrt((bins.max() - bins.min()) / bins.mean())\\n scores = np.log(bins / (bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins) / 2\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the item's size divided by the bin's remaining capacity, multiplied by the logarithm of the number of times the bin has been used plus one, and finally divided by the mean value of the differences between consecutive bins' capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.sqrt(item / (bins - item)) * np.log(np.arange(len(bins)) + 1) / weight\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / len(bins)\\n scores = np.log(bins) / (bins - item) * np.log10(np.arange(1, len(bins) + 1)) * weight ** np.sqrt(item / bins)\\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / (len(bins) - 1)\\n scores = np.log(bins) / (bins - item) * np.log10(np.arange(1, len(bins) + 1)) * weight ** np.sqrt(item / bins)\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.sqrt((bins.max() - bins.mean()) / len(bins))\\n scores = np.log(bins / (bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. In this modified version, an additional factor is introduced where the score is multiplied by a factor of the bin's current capacity divided by the maximum capacity, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n max_capacity = np.max(bins)\\n scores = bins / np.sqrt(bins - item) * (bins / max_capacity) ** 2 + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. However, the weight value is modified to be the square root of the difference between the maximum capacity of the bins and the average capacity of the bins.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = np.sqrt((bins.max() - bins.mean()) / len(bins))\\n scores = np.log(bins / (bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.02425,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, plus a constant weight value and raised to the power of the square root of the item's size divided by the bin's capacity, multiplied by the item size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / (len(bins) - 1)\\n scores = np.log(bins) / (bins - item) * np.log10(np.arange(1, len(bins) + 1)) * weight ** np.sqrt(item / bins) * (item / bins)\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the log of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.exp(bins / item + np.sqrt(np.arange(1, len(bins) + 1))) ** (np.log(bins) / (item - bins)) * weight\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n# New Algorithm Description:\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 2. \\n\\n# New Algorithm Steps:\\n1. Calculate the weight value as 2 * (bins.max() - bins.mean())^2.\\n2. Calculate the scores for each bin using the formula:\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight.\\n\\n# Implementation of the new score function in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * (bins.max() - bins.mean()) ** 2\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 3.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 3 * (bins.max() - bins.mean()) ** 2\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / (len(bins) - 1)\\n scores = bins / (bins - item) * (np.arange(1, len(bins) + 1)) * weight\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = 1 / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / ((bins - item)**2) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared and multiplied by a weight value.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins))**2 * weight\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins) / 2\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the square root of the item's size divided by the bin's remaining capacity, multiplied by the logarithm of the number of times the bin has been used plus one, and finally divided by the mean value of the differences between consecutive bins' capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.sqrt(item / (bins - item)) * np.log(np.arange(len(bins)) + 1) / weight\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / len(bins)\\n scores = np.log(bins) / (bins - item) * np.log10(np.arange(1, len(bins) + 1)) * weight ** np.sqrt(item / bins)\\n return scores\",\n \"objective\": 0.02153,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / (len(bins) - 1)\\n scores = np.log(bins) / (bins - item) * np.log10(np.arange(1, len(bins) + 1)) * weight ** np.sqrt(item / bins)\\n return scores\",\n \"objective\": 0.02163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.sqrt((bins.max() - bins.mean()) / len(bins))\\n scores = np.log(bins / (bins - item) + np.arange(len(bins)) * weight)\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value. In this modified version, an additional factor is introduced where the score is multiplied by a factor of the bin's current capacity divided by the maximum capacity, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2.0\\n scores = bins / np.sqrt(bins - item) * (bins / np.max(bins)) ** 2 + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the log of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.exp(bins / item + np.sqrt(np.arange(1, len(bins) + 1))) ** (np.log(bins) / (item - bins)) * weight\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, and the square root of the ratio of the bin's current capacity to the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins.\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.0 # Fixed weight\\n scores = np.log(bins / (bins - item)) + np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item) * weight\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the exponential of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, the number of times the bin has been used, and additional weighting factors.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the bin's current capacity plus the number of times the bin has been used, raised to the power of the item's size times the square root of the bin's capacity, and multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 2.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * (bins.max() - bins.mean())\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins)) * weight\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n# New Algorithm Description:\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 2. \\n\\n# New Algorithm Steps:\\n1. Calculate the weight value as 2 * (bins.max() - bins.mean())^2.\\n2. Calculate the scores for each bin using the formula:\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight.\\n\\n# Implementation of the new score function in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * (bins.max() - bins.mean()) ** 2\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 3.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 3 * (bins.max() - bins.mean()) ** 2\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / (len(bins) - 1)\\n scores = bins / (bins - item) * (np.arange(1, len(bins) + 1)) * weight\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = 1 / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / ((bins - item)**2) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared and multiplied by a weight value.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins))**2 * weight\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins) / 2\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the log of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5\\n scores = np.exp(bins / item + np.sqrt(np.arange(1, len(bins) + 1))) ** (np.log(bins) / (item - bins)) * weight\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\\"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, and the square root of the ratio of the bin's current capacity to the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins.\\\"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.0 # Fixed weight\\n scores = np.log(bins / (bins - item)) + np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item) * weight\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (item - bins) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the exponential of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, the number of times the bin has been used, and additional weighting factors.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the bin's current capacity plus the number of times the bin has been used, raised to the power of the item's size times the square root of the bin's capacity, and multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 2.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * (bins.max() - bins.mean())\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins)) * weight\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the cosine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, and then multiplied by the sine of the absolute difference between the maximum and minimum capacity of the bins, divided by the count of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.cos(bins / (bins - item)) + (bins / np.arange(1, len(bins) + 1))**(bins - item)**2 * weight * np.sin(np.abs(bins.max() - bins.min()) / len(bins))\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the exponential of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins / (bins - item)) + (bins / np.arange(1, len(bins) + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\n# New Algorithm Description:\\nThe new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 2. \\n\\n# New Algorithm Steps:\\n1. Calculate the weight value as 2 * (bins.max() - bins.mean())^2.\\n2. Calculate the scores for each bin using the formula:\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight.\\n\\n# Implementation of the new score function in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * (bins.max() - bins.mean()) ** 2\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = bins / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01922,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the square root of the difference between the maximum capacity of the bins and the average capacity of the bins, plus the number of times the bin has been used, multiplied by a weight value. The weight value is modified to be the square of the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 3.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 3 * (bins.max() - bins.mean()) ** 2\\n scores = np.log((bins / (bins - item)) * np.sqrt((bins.max() - bins.mean()))) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1.5 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01952,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the log of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the number of times the bin has been used, multiplied by a weight value and raised to the power of the square root of the item's size divided by the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (np.max(bins) - np.min(bins)) / (len(bins) - 1)\\n scores = bins / (bins - item) * (np.arange(1, len(bins) + 1)) * weight\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate the score for each bin based on its current capacity, the difference between its capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = 1 / (bins - item) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nImplementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) * (bins / np.arange(1,len(bins)+1))**bins\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/UniformRun3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the square root of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, which is the difference between the maximum capacity of the bins and the average capacity of the bins, squared multiplied by a factor of 5, divided by the number of items already assigned to bins.\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_items = len(bins)\\n weight = 5 * ((bins.max() - bins.mean()) ** 2) / num_items\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, num_items + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the product of the current capacity of the bin divided by the item size, plus the square root of the number of times the bin has been used, all raised to the power of the natural logarithm of the bin's capacity divided by the difference between the item size and the bin's capacity, and then multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) / (item - bins) * (np.sqrt(np.arange(1, len(bins) + 1)) + bins / item))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the logarithm of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the square root of the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item)) * np.sqrt(bins / np.arange(1, len(bins) + 1))**(bins - item)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and multiplied by the logarithm of the bin's current capacity divided by the item size, all multiplied by the exponential of the bin's current capacity divided by the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (bins / np.arange(1,len(bins)+1))**(bins - item) + np.log(bins / item) * np.exp(bins / item)\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, calculated as the exponential function of the bin's current capacity multiplied by the logarithm of the item size, plus the sum of the number of times the bin has been used and the weight value, all raised to the power of the square root of the bin's capacity divided by the difference between the item size and the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.exp(bins * np.log(item) + np.arange(len(bins)) + weight) ** (np.sqrt(bins) / (item - bins))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, and the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item))\\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(1) New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the square root of the ratio of the bin's current capacity to the item size, and the logarithm of the bin's current capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the natural logarithm of the bin's capacity minus the item size, and then multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins.\\n\\nImplementation in Python:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.mean()) / np.std(bins) # Weight modified by the difference between the maximum capacity of the bins and the average capacity of the bins, divided by the standard deviation of the capacities of the bins\\n scores = np.sqrt(bins / item) + np.log(bins - item) * (bins / np.arange(1, len(bins) + 1)) ** (np.log(bins - item)) * weight\\n return scores\",\n \"objective\": 0.01187,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity, and multiplied by the logarithm of the bin's current capacity.\\n\\nNew implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.abs(bins - item)) * (bins / np.arange(1,len(bins)+1))**(np.abs(bins-item)) * np.log(bins)\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * np.mean(np.diff(np.sort(bins)))\\n scores = np.log(bins) / (item - bins) + np.arange(len(bins)) * weight\\n return scores\",\n \"objective\": 0.01217,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the exponential of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(bins - item)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the product of the square root of the bin's current capacity divided by the bin's capacity minus the item size, the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size, and multiplied by the exponential of the bin's current capacity divided by the item size.\\n\\nNew implementation in Python:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins / (bins - item)) * (bins / np.arange(1,len(bins)+1))**(bins - item) * np.exp(bins / item)\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the square root of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity divided by the item size, squared and multiplied by a weight value.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.sqrt(bins / (bins - item)) + (bins / np.arange(1, len(bins) + 1))**(bins / item)**2 * weight\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign an item to the bin with the maximum score, which is calculated based on the current capacity and usage history of the bin.\\n\\nThe description of my new algorithm in one sentence: \\n\\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the sum of the bin's current capacity divided by the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity, squared and multiplied by a weight value, plus the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's current capacity divided by the item size, all raised to the power of the bin's current capacity minus the item size, squared and multiplied by the logarithm of the average capacity of the bins, squared and divided by the maximum capacity of the bins.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 0.5 # Simplified weight component\\n scores = (bins / item) * (np.log10(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins)) + ((bins**2) / (bins - item)) * (np.log(bins / item) * (bins / item))**2 * (bins - item)**2 * (np.log(np.mean(bins)))**2 / np.max(bins)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: All algorithms assign an item to the bin with the maximum score, which is calculated based on the current capacity and usage history of the bin.\\n\\nMy new algorithm assigns an item to the bin with the maximum score, calculated as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity, squared and multiplied by a weight value, plus the square of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's current capacity divided by the item size, all raised to the power of the bin's current capacity minus the item size, squared and multiplied by the logarithm of the average capacity of the bins, squared and divided by the maximum capacity of the bins.\\n\\nHere is the implementation of the new algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 0.5 # Simplified weight component\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins)) + ((bins / (bins - item))**2) * (np.log(bins / item) * (bins / item))**2 * (bins - item)**2 * (np.log(bins.mean()))**2 / bins.max()\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity plus the number of times the bin has been used, and raised to the power of the item's size times the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All algorithms calculate the score for each bin based on the bin's current capacity, the item size, the number of times the bin has been used, and additional weighting factors.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score, calculated as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, and the logarithm of the bin's current capacity plus the number of times the bin has been used, raised to the power of the item's size times the square root of the bin's capacity, and multiplied by a weight value modified by the difference between the maximum capacity of the bins and the average capacity of the bins, multiplied by a factor of 2.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 2 * (bins.max() - bins.mean())\\n scores = (bins / (bins - item)) * (np.log(bins) + np.arange(len(bins))) ** (item * np.sqrt(bins)) * weight\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the cosine of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value, and then multiplied by the sine of the absolute difference between the maximum and minimum capacity of the bins, divided by the count of bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = (bins.max() - bins.min()) / len(bins)\\n scores = np.cos(bins / (bins - item)) + (bins / np.arange(1, len(bins) + 1))**(bins - item)**2 * weight * np.sin(np.abs(bins.max() - bins.min()) / len(bins))\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the sum of the exponential of the bin's current capacity divided by the bin's capacity minus the item size, multiplied by the bin's current capacity divided by the number of times the bin has been used, and raised to the power of the bin's current capacity minus the item size, squared and multiplied by a weight value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight = 1\\n scores = np.exp(bins / (bins - item)) + (bins / np.arange(1, len(bins) + 1))**(bins - item)**2 * weight\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the log of the bin's current capacity divided by the bin's capacity minus the item size, squared, and then multiplied by the bin's current capacity divided by the number of times the bin has been used, raised to the power of the bin's current capacity minus the item size divided by the bin's current capacity minus the item size plus 1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins / (bins - item))**2 * (bins / np.arange(1, len(bins) + 1))**(bins - item / (bins - item + 1))\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function assigns items to bins based on the maximum score, while avoiding using bins at maximum capacity in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == np.max(bins)] = -1\\n scores = remaining_capacity / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with more remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, bins - item) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will assign a score to each bin based on the remaining capacity after placing the item. The score will be calculated by taking the reciprocal of the difference between the bin capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity. Higher scores indicate better candidates for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.15595,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm calculates the score for each bin based on the rest capacity and assigns the item to the bin with the maximum score, aiming to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = np.maximum(0, max_capacity - bins) # Calculate rest capacity\\n mask = rest_capacity < item # Check if rest capacity is enough for the item\\n rest_capacity[mask] = 0 # Set rest capacity to 0 if it's not enough\\n scores = rest_capacity / (max_capacity * (1 - mask)) # Calculate scores for each bin\\n return scores\",\n \"objective\": 0.31975,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the score for each bin by taking the ratio of the rest capacity to the item size, and then subtracting 1 if the rest capacity equals the maximum capacity, in order to prioritize the bin with the largest available space but not the maximum capacity, with the main steps being to calculate the scores and return them as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm as follows:\\nThe algorithm will calculate the score for each bin based on the remaining capacity after assigning the item, with a penalty for bins at maximum capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) - (bins == bins.max()) * (item + 1)\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the remaining capacity of each bin after assigning the item, and then assigns a score to each bin based on the ratio of remaining capacity to the maximum capacity, with a penalty for bins with maximum capacity. It then returns the scores for all bins using Numpy array. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_ratio = remaining_capacity / np.max(bins)\\n remaining_ratio[bins == np.max(bins)] -= 0.5 # Apply penalty for bins with maximum capacity\\n scores = remaining_ratio\\n return scores\",\n \"objective\": 0.40739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves ranking the bins based on their remaining capacity after assigning the item, and penalizing bins with maximum capacity to discourage their use. First, calculate the remaining capacity of each bin after assigning the item, then calculate the score for each bin by considering its remaining capacity and penalizing bins with maximum capacity. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalized_capacity = np.where(remaining_capacity < np.max(remaining_capacity), remaining_capacity, np.max(remaining_capacity) * 2)\\n scores = penalized_capacity * (1 + np.log(1 + np.abs(penalized_capacity - np.max(penalized_capacity))))\\n return scores\",\n \"objective\": 0.5735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the minimum between the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.maximum(bins - item, 0)\\n scores = np.minimum(capacities, item)\\n return scores\",\n \"objective\": 0.64021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: First, calculate the free space in each bin after adding the item, then compute the score for each bin using a novel formula that takes into account the free space and the distance from the maximum capacity, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_space = bins - item\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - remaining_space\\n scores = remaining_space * (1 + distance_from_max)\\n return scores\",\n \"objective\": 0.77412,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the following formula: score = (bin_capacity - item_size) * (1 - bin_index/N), where N is the total number of bins. Then, the function will return the scores for each bin in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n scores = (bins - item) * (1 - np.arange(N)/N)\\n return scores\",\n \"objective\": 0.89174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacity of each bin after adding the item, and then scores each bin based on the formula: ((maximum capacity - available capacity) / maximum capacity) * available capacity, where bins with the maximum capacity are not scored. Finally, the function returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n available_capacity = np.maximum(0, (bins + item) - max_capacity)\\n scores = ((max_capacity - available_capacity) / max_capacity) * available_capacity\\n scores[available_capacity == 0] = 0\\n return scores\",\n \"objective\": 1.21401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplementing the algorithm:\\n1. Create a function named score that accepts two input parameters: 'item' and 'bins'.\\n2. Inside the function, calculate the scores for each bin by first finding the difference between the maximum capacity of each bin and the size of the item.\\n3. For bins that have a rest capacity equal to the maximum capacity, assign a score of -1 to make them ineligible for item assignment.\\n4. Return the calculated scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == bins.max()).astype(int) * -1\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm: The algorithm first calculates the scores for each bin based on the rest capacity and the current item size, then it returns the scores for the bins for assignment.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0)\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, raised to the power of 0.5, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 0.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the ratio of the item size to the remaining capacity and the remaining capacity itself, ensuring that bins with lower ratios and higher remaining capacities have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (ratios + remaining_capacity) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, squared, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the remaining capacity divided by the item size, ensuring that bins with higher remaining capacities and lower ratios have higher scores. The scores are then multiplied by the ratio of the remaining capacity to the maximum capacity, squared, and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / item\\n scores = np.log(ratios)\\n scores *= (remaining_capacity / max_capacity) ** 2\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the inverse of the product between the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with lower remaining capacity and higher ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = 1 / (remaining_capacity * np.log(item / remaining_capacity))\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the product of the remaining capacity and the logarithm of the item size to the remaining capacity, squared, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity * np.log(item / remaining_capacity) ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio of the item size to the remaining capacity, ensuring that bins with higher remaining capacities and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity, and a constant value is subtracted for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n scores = remaining_capacity * ratios / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm aims to prioritize the bins with the least remaining capacity by assigning higher scores to them, while still giving a maximum score to bins with full capacity. This ensures that the bins with the least capacity are used first, reducing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity and the difference between the bin capacity and the item size, where bins with higher remaining capacity and lower difference will have higher scores. The scores are then adjusted based on the maximum capacity, and set to -infinity for bins with maximum capacity. The final scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacities = bins - item\\n differences = bins - item\\n \\n scores = (rest_capacities / max_capacity) * (1 - differences)\\n scores[bins == max_capacity] = -np.inf\\n \\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the product of the remaining capacity and the ratio of the item size to the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on a penalty factor for bins at maximum capacity, and the final scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * ratios\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the inverse of the difference between the bin capacity and the item size, ensuring that bins with higher remaining capacity and lower differences will have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n differences = bins - item\\n \\n scores = (remaining_capacity * (1 / differences)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the logarithm of the product of the remaining capacity and the ratio of the item size to the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity by subtracting a constant value, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = remaining_capacity * ratios / max_capacity\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the logarithm of the product of the remaining capacity and the ratio of the item size to the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity by subtracting a constant value, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = np.log(remaining_capacity * ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the remaining capacity and the difference between the remaining capacity and the item size, sort the bins in descending order, assign the item to the bin with the maximum score, and not use bins with maximum capacity, with the final goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n max_capacity = max(bins)\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max_capacity] = -1\\n scores = ((rest_capacities - item) / np.arange(1, len(sorted_bins) + 1)) * (bins != max_capacity)\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins using a combination of squared, logarithmic, and exponential functions. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.power(remaining_capacity / max_capacity, 2) * np.log(ratios) * np.exp(-ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the remaining capacity and the logarithm of the ratio of the item size to the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity by subtracting a constant value, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = np.log(ratios) * remaining_capacity / max_capacity\\n scores[bins == max_capacity] -= 1\\n return scores\",\n \"objective\": 0.0491,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity + item) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher sum values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n sum_scores = (remaining_capacity % item) * np.log(remaining_capacity) + np.sqrt(item / remaining_capacity) + np.exp(item * remaining_capacity)\\n \\n scores = sum_scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores /= np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins - item + 1 / (item / (bins - item)) + 1 / np.sqrt(bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio inverses, lower cosine ratios, and higher logarithmic values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratio_inverse = 1 / (item / remaining_capacity)\\n cosine_ratio = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n \\n scores = remaining_capacity + ratio_inverse + cosine_ratio + log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the natural logarithm of the item size divided by the remainder of the capacity divided by the item size, the square of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with higher natural logarithm values, lower square ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n log_division = np.log(item / (remaining_capacity % item))\\n square_ratio = (item / remaining_capacity)**2\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_division + square_ratio + exp_product\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n remaining_capacity_normalized = remaining_capacity / max_capacity\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity_normalized)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the sum of the remaining capacity and the item size, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + (np.sqrt(remaining_capacity) + item) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size, the reciprocal of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower item size values, higher reciprocal values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity + item**2 + (1 / remaining_capacity) + np.log(remaining_capacity)\\n scores = scores / np.max(bins)\\n scores[remaining_capacity == np.max(remaining_capacity)] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher logarithmic values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity + np.sqrt(ratios) + np.log(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, and penalizes bins with maximum capacity. The scores are then scaled by the logarithm of the bin's remaining capacity and the exponential of the negative ratio. Finally, the scores are adjusted based on the maximum capacity of the bins and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, raised to the power of 0.5, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 0.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square of the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity) ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the ratio of the item size to the remaining capacity and the remaining capacity itself, ensuring that bins with lower ratios and higher remaining capacities have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (ratios + remaining_capacity) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, penalizes bins at the maximum capacity, and adjusts the scores based on the maximum capacity and minimum capacity of the bins. The scores are then scaled by the inverse of the difference between the item size and the remaining capacity, and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * np.log(item / remaining_capacity)) / (item - remaining_capacity)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, squared, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the sum of the logarithm of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (np.log(remaining_capacity) + np.sqrt(ratios)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the ratio of the item size to the remaining capacity, a weight factor that is inversely proportional to the maximum capacity of the bins, the ratio of the remaining capacity to the maximum capacity, and a penalty term to further penalize bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (remaining_capacity / max_capacity) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.03018,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the remaining capacity divided by the item size, ensuring that bins with higher remaining capacities and lower ratios have higher scores. The scores are then multiplied by the ratio of the remaining capacity to the maximum capacity, squared, and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / item\\n scores = np.log(ratios)\\n scores *= (remaining_capacity / max_capacity) ** 2\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the inverse of the product between the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with lower remaining capacity and higher ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = 1 / (remaining_capacity * np.log(item / remaining_capacity))\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.0322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the product of the remaining capacity and the logarithm of the item size to the remaining capacity, squared, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity * np.log(item / remaining_capacity) ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.03471,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, raised to the power of 0.8, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 0.8) / max_capacity\\n scores[bins == max_capacity] -= 0.7\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = np.sqrt(remaining_capacity) + np.log(ratios)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.03532,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the logarithm of the ratio of the item size to each bin's remaining capacity, and adjusts the scores based on the maximum capacity of the bins. The scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item / remaining_capacity)\\n \\n scores = ratios * (max_capacity - bins) / max_capacity\\n \\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the difference between the bin capacity and the item size, penalizing bins with maximum capacity and adjusting the scores based on the maximum and minimum capacities of the bins. The scores are then scaled by the logarithm of the ratio between the item size and the remaining capacity, and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n differences = bins - item\\n \\n scores = 1 / (bins - item)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n scores = scores * np.log(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n average_capacity = np.average(bins) # Modified component\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / average_capacity # Modified component\\n scores[bins == np.max(bins)] -= 0.5 # Reverted back to original component\\n \\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the harmonic mean of the item size and the remaining capacity, the square root of the logarithm of the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n harmonic_mean = 2 / (1/item + 1/remaining_capacity)\\n sqrt_log_capacity = np.sqrt(np.log(remaining_capacity))\\n \\n scores = harmonic_mean * sqrt_log_capacity\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size divided by the remaining capacity, the logarithm of the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factors have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_factor = np.sqrt(item) / remaining_capacity\\n log_factor = np.log(remaining_capacity) ** 2\\n \\n scores = (remaining_capacity * sqrt_factor * log_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**3\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n square_root_ratios = np.sqrt(ratios)\\n log_factor = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity * square_root_ratios) ** 1.2 * (1 - log_factor ** 4) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the cube root of the remaining capacity and the item size, the logarithm of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher cube roots, lower logarithmic values, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (np.cbrt(remaining_capacity) * item) + np.log(remaining_capacity) + (1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns scores to each bin based on the remaining capacity, the cosine of the ratio between the item size and the remaining capacity, the Natural logarithm of the remaining capacity, and the inverse of the inverse values of the remaining capacity raised to the power of 0.1, with higher scores given to bins with higher remaining capacity, lower cosine ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n cosine_ratios = np.cos(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n inverse_inverse = 1 / (1 / remaining_capacity)**0.1\\n \\n scores = remaining_capacity + 2 * cosine_ratios + 3 * log_capacity + inverse_inverse\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the exponential of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n exponential_factor = np.exp2(item / remaining_capacity)\\n \\n scores = (remaining_capacity * np.sqrt(ratios)) ** 1.2 * (1 - exponential_factor) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = (item**2) / remaining_capacity**4\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the logarithm of the remainder of the capacity divided by the item size, the square root of the ratio between the item size and the remaining capacity, and the exponential of the product of the item size and the remaining capacity, with higher scores given to bins with lower logarithmic values, lower square root ratios, and higher exponential values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n \\n log_remainder = np.log(remaining_capacity % item)\\n sqrt_ratio = np.sqrt(item / remaining_capacity)\\n exp_product = np.exp(item * remaining_capacity)\\n \\n scores = log_remainder + sqrt_ratio + exp_product\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 6, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**6)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / (np.cbrt(item * (bins - item))) + (bins - item)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the cube root of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the factor of the logarithm of the item size to the remaining capacity raised to the power of 4, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n\\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**4)\\n scores[bins == max_capacity] -= 0.5\\n\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.log(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.sqrt(remaining_capacity % item)) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, and penalizes bins with maximum capacity. The scores are then scaled by the logarithm of the bin's remaining capacity and the exponential of the negative ratio. Finally, the scores are adjusted based on the maximum capacity of the bins and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe common backbone idea in the provided algorithms is to assign scores to each bin based on the remaining capacity and the ratio between the item size and the remaining capacity, while considering the maximum capacity of the bins and penalizing bins at maximum capacity.\\n\\nMy new algorithm assigns scores to each bin based on the sum of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the cube root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher cube root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = remaining_capacity + np.log(ratios) + np.cbrt(remaining_capacity)\\n scores = scores / np.mean(bins) # Replaced 'max_capacity' with 'np.mean(bins)'\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe common backbone idea in the provided algorithms is to assign scores to each bin based on the remaining capacity and the ratio between the item size and the remaining capacity, while considering the maximum capacity of the bins and penalizing bins at maximum capacity.\\n\\nMy new algorithm assigns scores to each bin based on the sum of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the cube root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher cube root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = remaining_capacity + np.log(ratios) + np.cbrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, raised to the power of 0.5, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 0.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square of the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity) ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the square of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, raised to the power of 1.5, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity ** 2) * (np.log(ratios) ** 1.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the ratio of the item size to the remaining capacity and the remaining capacity itself, ensuring that bins with lower ratios and higher remaining capacities have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (ratios + remaining_capacity) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The scores are calculated by multiplying the remaining capacity by the logarithm of the ratio between the item size and the remaining capacity, raised to the power of 1.5, and adjusted based on the maximum capacity and penalized for bins at maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * np.log(ratios)) ** 1.5 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.0172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the logarithm of the bin's remaining capacity and the square root of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacities and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity of the bins and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) + np.sqrt(ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01771,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, penalizes bins at the maximum capacity, and adjusts the scores based on the maximum capacity and minimum capacity of the bins. The scores are then scaled by the inverse of the difference between the item size and the remaining capacity, and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * np.log(item / remaining_capacity)) / (item - remaining_capacity)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, raised to the power of 1.5, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 1.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.02334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, penalizes bins with maximum capacity, and then adjusts the scores based on the maximum capacity and the average capacity of the bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.clip(bins - item, 0, None)\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n max_scores = np.sum(scores[bins == max_capacity]) - np.count_nonzero(scores)\\n scores[bins == max_capacity] -= max_scores / np.count_nonzero(bins == max_capacity)\\n scores -= np.mean(scores)\\n \\n return scores\",\n \"objective\": 0.02445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, penalizes bins with maximum capacity, and then adjusts the scores based on the maximum capacity and the average capacity of the bins. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n scores -= np.mean(scores) * max_capacity / bins\\n \\n return scores\",\n \"objective\": 0.02767,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, squared, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.02898,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the sum of the logarithm of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (np.log(remaining_capacity) + np.sqrt(ratios)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"(bins - item) / (np.log(item) * (bins - item))**0.7 - 0.5*(bins == np.max(bins))\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the remaining capacity, the logarithm of the remaining capacity, and a sine function of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity, lower square root values, higher logarithmic values, and lower sine values have higher scores. The scores are further adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_values = np.sqrt(remaining_capacity)\\n log_values = np.log(remaining_capacity)\\n sine_values = np.sin(item / remaining_capacity)\\n scores = remaining_capacity + sqrt_values + log_values + sine_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the cube root of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, lower cube root values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n cube_root = np.cbrt(remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + cube_root\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = 1 / (item / remaining_capacity)\\n sqrt_values = 1 / np.sqrt(remaining_capacity)\\n scores = remaining_capacity + ratios + sqrt_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, and penalizes bins with maximum capacity. The scores are then scaled by the logarithm of the bin's remaining capacity and the exponential of the negative ratio. Finally, the scores are adjusted based on the maximum capacity of the bins and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe common backbone idea in the provided algorithms is to assign scores to each bin based on the remaining capacity and the ratio between the item size and the remaining capacity, while considering the maximum capacity of the bins and penalizing bins at maximum capacity.\\n\\nMy new algorithm assigns scores to each bin based on the sum of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the cube root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher cube root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = remaining_capacity + np.log(ratios) + np.cbrt(remaining_capacity)\\n scores = scores / np.mean(bins) # Replaced 'max_capacity' with 'np.mean(bins)'\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (item * remaining_capacity)\\n scores = remaining_capacity + ratios\\n scores = scores / np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates scores for each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, the maximum capacity of the bins, and the number of already assigned items to each bin, ensuring that bins with higher remaining capacity, lower ratios, lower number of assigned items, and higher maximum capacity have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 - num_assigned_items / len(bins))\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the ratio of the item size to the remaining capacity, raised to the power of 0.5, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + ratios ** 0.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, raised to the power of 2.5, ensuring that bins with higher remaining capacity, lower ratios, and lower maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (np.sqrt(remaining_capacity) * np.log(ratios) ** 2.5) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square of the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity) ** 2) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n scores = (remaining_capacity + np.log(item / remaining_capacity)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01298,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the remaining capacity, the logarithm of the remaining capacity, and a sine function of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity, lower square root values, higher logarithmic values, and lower sine values have higher scores. The scores are further adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_values = np.sqrt(remaining_capacity)\\n log_values = np.log(remaining_capacity)\\n sine_values = np.sin(item / remaining_capacity)\\n scores = remaining_capacity + sqrt_values + log_values + sine_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the cube root of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, lower cube root values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n cube_root = np.cbrt(remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + cube_root\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, and the exponential of the square root of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, and lower square root ratios. The scores are then normalized based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios)\\n scores = remaining_capacity + log_capacity*exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = 1 / (item / remaining_capacity)\\n sqrt_values = 1 / np.sqrt(remaining_capacity)\\n scores = remaining_capacity + ratios + sqrt_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's remaining capacity, and penalizes bins with maximum capacity. The scores are then scaled by the logarithm of the bin's remaining capacity and the exponential of the negative ratio. Finally, the scores are adjusted based on the maximum capacity of the bins and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = np.log(remaining_capacity) * np.exp(-ratios)\\n scores[bins == max_capacity] -= (np.sum(scores) - np.count_nonzero(scores)) / np.count_nonzero(bins == max_capacity)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (item * remaining_capacity)\\n scores = remaining_capacity + ratios\\n scores = scores / np.max(bins)\\n scores[bins == np.max(bins)] -= 0.5\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the mean capacity of the bins, ensuring that bins with higher remaining capacity, lower logarithmic ratios, and higher mean capacity have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n mean_capacity = np.mean(bins)\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (mean_capacity / max_capacity)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size to the remaining capacity, and the square of the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the remaining capacity, the logarithm of the remaining capacity, and a sine function of the ratio between the item size and the remaining capacity, ensuring that bins with higher remaining capacity, lower square root values, higher logarithmic values, and lower sine values have higher scores. The scores are further adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n sqrt_values = np.sqrt(remaining_capacity)\\n log_values = np.log(remaining_capacity)\\n sine_values = np.sin(item / remaining_capacity)\\n scores = remaining_capacity + sqrt_values + log_values + sine_values\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the cube root of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, lower cube root values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n cube_root = np.cbrt(remaining_capacity)\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + cube_root\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the remaining capacity, the cube root of the item size to the remaining capacity, and the cube of the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.cbrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher inverse values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n inverse_capacity = 1 / remaining_capacity\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + inverse_capacity\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is a modification of the original algorithm. It assigns scores to each bin based on a combination of the remaining capacity, the ratio of the item size to the remaining capacity, and a weight factor that is inversely proportional to the maximum capacity of the bins, ensuring that bins with higher remaining capacity, lower ratios, and smaller maximum capacities have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios) * (1 / max_capacity)\\n scores[bins == max_capacity] -= 0.5 * (1 / max_capacity)\\n \\n return scores\",\n \"objective\": 0.01056,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the item size to the remaining capacity, and the square of the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity, and the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher inverse values, and higher logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.sqrt(item / remaining_capacity)\\n inverse_capacity = 1 / remaining_capacity\\n scores = remaining_capacity + np.log(remaining_capacity) + ratios + inverse_capacity\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the remaining capacity, the factor of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = item / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio of the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - ratios)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01046,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower ratios have higher scores, and it penalizes bins at maximum capacity. The scores are then adjusted based on the maximum capacity and returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = remaining_capacity * (1 - ratios) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the logarithm of the item size divided by the remaining capacity, raised to the power of 0.8, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity + (logarithm ** 0.8)) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remaining capacity and the square root of the ratio between the item size and the remaining capacity, raised to the power of 1.2, ensuring that bins with higher remaining capacity and lower ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity * (ratios ** (1/2))) ** 1.2 / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = np.sqrt(item) / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on a modified version of the original algorithm, where the score is calculated as the sum of two terms: the first term considers the remaining capacity of the bin and the logarithm of the item size, and the second term penalizes bins with the maximum capacity by subtracting a constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = (remaining_capacity) / (np.log(item) * (remaining_capacity)) ** 0.7 - 0.5*(bins == max_capacity)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the product of the remainder of the capacity divided by the item size and the logarithm of the remaining capacity, with higher scores given to bins with higher remainders and lower logarithmic values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity % item) * np.log(remaining_capacity)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the remaining capacity, the square root of the remaining capacity, and the exponential of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, higher logarithmic values, higher square root values, and higher exponential values. The scores are then adjusted based on the maximum capacity and bins at the maximum capacity are further penalized, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt(remaining_capacity) + np.exp(1 / remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the cube root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.cbrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the square root of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower logarithm of square root ratios, and higher square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(np.sqrt(item / remaining_capacity))\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the sum of the remaining capacity and the square root of the product of the item size and the logarithm of the remaining capacity, divided by the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the square root have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root = np.sqrt(item * np.log(remaining_capacity))\\n \\n scores = (remaining_capacity + square_root) / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the item size to the remaining capacity raised to the power of 2, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the logarithm have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n logarithm = np.log(item) / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 - logarithm**2)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n \\n scores = remaining_capacity + 2 * ratios_sqrt + 3 * log_capacity - 0.5 * exp_ratios\\n \\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity, the square root of the ratio between the item size and the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher square root ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n square_root_ratios = np.sqrt(item / remaining_capacity)\\n \\n scores = (remaining_capacity / max_capacity) * (1 + square_root_ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the cube root of the square root of the inverse of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower ratio values, higher logarithmic values, and higher cube root of square root values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity) + np.sqrt((1 / remaining_capacity))**0.3333333333333333\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the logarithm of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, lower ratios, and higher square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = np.log(item / remaining_capacity)\\n scores = remaining_capacity + np.sqrt(remaining_capacity) + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the cube root of the ratio between the item size and the remaining capacity, the inverse of the remaining capacity raised to the power of 0.5, and the square of the logarithm of the remaining capacity, with higher scores given to bins with higher remaining capacity, lower cube root ratios, higher inverse values, and higher square logarithmic values. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.log(remaining_capacity)**2\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on a combination of the remaining capacity, the inverse of the ratio between the item size and the remaining capacity, and the square root of the remaining capacity, ensuring that bins with higher remaining capacity, larger ratios, and smaller square root values have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + 1 / (item / remaining_capacity) + 1 / np.sqrt(remaining_capacity)\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the exponential of the ratio between the item size and the remaining capacity, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and lower exponential ratios. The scores are then adjusted based on the maximum capacity and further penalized for bins at the maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios_sqrt = np.sqrt(item / remaining_capacity)\\n log_capacity = np.log(remaining_capacity)\\n exp_ratios = np.exp(-ratios_sqrt)\\n scores = remaining_capacity + ratios_sqrt + log_capacity + exp_ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the square root of the ratio between the item size and the remaining capacity, the logarithm of the remaining capacity, and the inverse values of the remaining capacity raised to the power of 0.25, with higher scores given to bins with higher remaining capacity, lower square root ratios, higher logarithmic values, and higher inverse values of the remaining capacity.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n scores = remaining_capacity + np.sqrt(item / remaining_capacity) + np.log(remaining_capacity) + 1.0 / remaining_capacity**0.25\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the remaining capacity, the factor of the square root of the item size to the remaining capacity raised to the power of 3, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and lower values of the factor have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n factor = 1 / remaining_capacity\\n scores = (remaining_capacity / max_capacity) * (1 - factor**3)\\n scores[bins == max_capacity] -= 0.5\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity, the logarithm of the item size to the remaining capacity, and the maximum capacity of the bins, ensuring that bins with higher remaining capacity and higher logarithmic ratios have higher scores. The scores are then adjusted based on the maximum capacity and penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n \\n ratios = item / remaining_capacity\\n \\n scores = (remaining_capacity / max_capacity) * (1 + ratios)\\n scores[bins == max_capacity] = 0.5\\n \\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity divided by the square root of the item size multiplied by the remaining capacity, with a penalty for bins at maximum capacity, ensuring that bins with higher remaining capacity and larger ratios have higher scores. The scores are then adjusted based on the maximum capacity and further penalized for bins at maximum capacity, returning the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = bins - item\\n ratios = remaining_capacity / (np.sqrt(item * remaining_capacity))\\n scores = remaining_capacity + ratios\\n scores = scores / max_capacity\\n scores[bins == max_capacity] -= 0.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function assigns items to bins based on the maximum score, while avoiding using bins at maximum capacity in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == np.max(bins)] = -1\\n scores = remaining_capacity / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with more remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, bins - item) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will assign a score to each bin based on the remaining capacity after placing the item. The score will be calculated by taking the reciprocal of the difference between the bin capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity. Higher scores indicate better candidates for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.15595,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm calculates the score for each bin based on the rest capacity and assigns the item to the bin with the maximum score, aiming to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = np.maximum(0, max_capacity - bins) # Calculate rest capacity\\n mask = rest_capacity < item # Check if rest capacity is enough for the item\\n rest_capacity[mask] = 0 # Set rest capacity to 0 if it's not enough\\n scores = rest_capacity / (max_capacity * (1 - mask)) # Calculate scores for each bin\\n return scores\",\n \"objective\": 0.31975,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the score for each bin by taking the ratio of the rest capacity to the item size, and then subtracting 1 if the rest capacity equals the maximum capacity, in order to prioritize the bin with the largest available space but not the maximum capacity, with the main steps being to calculate the scores and return them as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm as follows:\\nThe algorithm will calculate the score for each bin based on the remaining capacity after assigning the item, with a penalty for bins at maximum capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) - (bins == bins.max()) * (item + 1)\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the remaining capacity of each bin after assigning the item, and then assigns a score to each bin based on the ratio of remaining capacity to the maximum capacity, with a penalty for bins with maximum capacity. It then returns the scores for all bins using Numpy array. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_ratio = remaining_capacity / np.max(bins)\\n remaining_ratio[bins == np.max(bins)] -= 0.5 # Apply penalty for bins with maximum capacity\\n scores = remaining_ratio\\n return scores\",\n \"objective\": 0.40739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves ranking the bins based on their remaining capacity after assigning the item, and penalizing bins with maximum capacity to discourage their use. First, calculate the remaining capacity of each bin after assigning the item, then calculate the score for each bin by considering its remaining capacity and penalizing bins with maximum capacity. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalized_capacity = np.where(remaining_capacity < np.max(remaining_capacity), remaining_capacity, np.max(remaining_capacity) * 2)\\n scores = penalized_capacity * (1 + np.log(1 + np.abs(penalized_capacity - np.max(penalized_capacity))))\\n return scores\",\n \"objective\": 0.5735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the minimum between the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.maximum(bins - item, 0)\\n scores = np.minimum(capacities, item)\\n return scores\",\n \"objective\": 0.64021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: First, calculate the free space in each bin after adding the item, then compute the score for each bin using a novel formula that takes into account the free space and the distance from the maximum capacity, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_space = bins - item\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - remaining_space\\n scores = remaining_space * (1 + distance_from_max)\\n return scores\",\n \"objective\": 0.77412,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the following formula: score = (bin_capacity - item_size) * (1 - bin_index/N), where N is the total number of bins. Then, the function will return the scores for each bin in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n scores = (bins - item) * (1 - np.arange(N)/N)\\n return scores\",\n \"objective\": 0.89174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacity of each bin after adding the item, and then scores each bin based on the formula: ((maximum capacity - available capacity) / maximum capacity) * available capacity, where bins with the maximum capacity are not scored. Finally, the function returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n available_capacity = np.maximum(0, (bins + item) - max_capacity)\\n scores = ((max_capacity - available_capacity) / max_capacity) * available_capacity\\n scores[available_capacity == 0] = 0\\n return scores\",\n \"objective\": 1.21401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplementing the algorithm:\\n1. Create a function named score that accepts two input parameters: 'item' and 'bins'.\\n2. Inside the function, calculate the scores for each bin by first finding the difference between the maximum capacity of each bin and the size of the item.\\n3. For bins that have a rest capacity equal to the maximum capacity, assign a score of -1 to make them ineligible for item assignment.\\n4. Return the calculated scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == bins.max()).astype(int) * -1\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm: The algorithm first calculates the scores for each bin based on the rest capacity and the current item size, then it returns the scores for the bins for assignment.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0)\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the remaining capacity and the index value of the bins, with higher weights given to bins with more capacity and lower index values, to encourage the utilization of bins with more space and bins that have not been assigned items yet. The algorithm will also penalize bins at maximum capacity, with a higher penalty factor for bins with lower index values, and reward bins with higher remaining capacity. In addition, it will introduce a new factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n penalty_factor = 10000\\n reward_capacity_factor = 100\\n reward_index_factor = 10\\n penalty_item_factor = 1000\\n\\n scores = np.zeros_like(bins, dtype=float)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (i + 1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (len(bins) - i) * reward_index_factor\\n item_weight = item * penalty_item_factor\\n scores[i] = weighted_capacity + index_weight - item_weight\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin based on the inverse of the absolute difference between the remaining capacity and the item size, multiplied by the logarithm of the remaining capacity, and subtract the position index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs((bins - item)) * np.log(bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with no penalty for bins at maximum capacity, and return the scores in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.mean(bins) - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the index value of the bins, and a penalty for bins at maximum capacity, with different weightings for each factor. The algorithm also takes into account the total number of bins used so far, penalizing bins with higher indices to encourage utilization of bins that have not been assigned items yet. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n penalty_factor = 10000\\n reward_capacity_factor = 100\\n reward_index_factor = 10\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (i + 1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (len(bins) - i) * reward_index_factor\\n scores[i] = weighted_capacity + index_weight\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will assign scores to the bins based on a combination of factors including the remaining capacity, the index value of the bins, and a penalty for bins at maximum capacity. The weights for each factor will be adjusted to penalize bins at maximum capacity more heavily, and bins with higher remaining capacity and lower index value will be rewarded. The algorithm will also include a factor that decreases the score for bins that have already been assigned items, in order to encourage the utilization of bins that have not been used yet.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 15000\\n reward_capacity_factor = 1200\\n reward_index_factor = 300\\n reward_unassigned_factor = 600\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (1 - (i / len(bins))) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (len(bins) - i) * reward_index_factor\\n unassigned_weight = (1 - (bins[i] / max_capacity)) * reward_unassigned_factor\\n scores[i] = weighted_capacity + index_weight - unassigned_weight\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the remaining capacity, the index value of the bins, and a penalty for bins at maximum capacity. The algorithm will penalize bins at maximum capacity more heavily, reward bins with higher remaining capacity and lower index value, and include a factor that decreases the score for bins that have already been assigned items. The main steps are as follows: \\n- Calculate the maximum capacity of the bins.\\n- Create an array of scores with the same length as the bins array, initialized to zero.\\n- Iterate over the bins.\\n - If a bin has maximum capacity, assign a penalty score based on the bin's index value multiplied by a higher penalty factor.\\n - If a bin has remaining capacity, calculate the weighted capacity by subtracting its capacity from the maximum capacity and multiplying it by a reward factor. Add a penalty for bins with lower index values and a reward for bins with higher remaining capacity.\\n - Subtract a score factor for bins that have already been assigned items, based on the ratio of the remaining capacity to the maximum capacity of the bins.\\n - Calculate the score for the bin by summing the weighted capacity, the index value multiplied by a reward factor, and the score factor.\\n - Store the score in the scores array.\\n- Return the scores array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 5000\\n reward_capacity_factor = 300\\n reward_index_factor = 200\\n score_factor = 100\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (i / len(bins))\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (len(bins) - i) * reward_index_factor\\n score_weight = (1 - (bins[i] / max_capacity)) * score_factor\\n scores[i] = weighted_capacity + index_weight - score_weight\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the remaining capacity and the weighted sum of the index values of the bins, with higher weights given to bins with more capacity and lower index values to encourage the utilization of bins with more space and bins that have not been assigned items yet. The algorithm will also penalize bins at maximum capacity, with a higher penalty factor for bins with lower index values, and reward bins with higher remaining capacity, but with a lower reward factor for bins with higher index values. The main steps are as follows:\\n - Calculate the maximum capacity of the bins.\\n - Initialize the penalty and reward factors.\\n - Create an array of scores with the same length as the bins array, initialized to zero.\\n - Iterate over the bins.\\n - If a bin has maximum capacity, assign a penalty score based on the bin's index value.\\n - If a bin has remaining capacity, calculate the weighted capacity by subtracting its capacity from the maximum capacity and multiplying it by the reward factor.\\n - Calculate the index weight by multiplying the index value by the reward factor.\\n - Calculate the score for the bin by summing the weighted capacity and index weight.\\n - Store the score in the scores array.\\n - Return the scores array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 10000\\n reward_factor = 100\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (1 - (i / len(bins)))\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_factor\\n index_weight = i * reward_factor\\n scores[i] = weighted_capacity + index_weight\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin based on the inverse of the absolute difference between the remaining capacity and the item size, multiplied by the logarithm of the remaining capacity, and subtract the position index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs((bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity and the current item size, while also considering the cumulative sum of the bins, with bins having a lower cumulative sum being prioritized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n cumulative_sum = np.cumsum(bins)\\n scores = cumulative_sum - bins + item\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on a combination of the remaining capacity, a weighted sum of the index values of the bins, and a penalty term that increases with the index value squared, with higher weights given to bins with more capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n reward_factor = 100\\n \\n scores = bins - item + (np.arange(len(bins)) + 1) + (np.square(np.arange(len(bins)) + 1) * reward_factor)\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a higher penalty for bins at maximum capacity, a lower penalty for bins with higher remaining capacity, and a higher priority for bins with lower index values. The algorithm will use a modified version of the formula provided in the original algorithm to calculate the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 2000\\n priority_factor = 100\\n scores = np.zeros_like(bins, dtype=float)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = (1 / (remaining_capacity - item + 1)) - (i * priority_factor)\\n else:\\n scores[i] = ((1 + ((item + 1) % 2)) / (remaining_capacity - item + 1)) * penalty_factor - (i * priority_factor)\\n\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a higher penalty for bins at maximum capacity, a lower reward for bins with higher remaining capacity, and a higher priority for bins with lower index values. The algorithm will also use a modified version of the formula provided in the original algorithm to calculate the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 2000\\n reward_factor = 500\\n priority_factor = 100\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = (reward_factor / (remaining_capacity - item + 1)) - (i * priority_factor)\\n else:\\n scores[i] = ((1 + ((item + 1) % 2)) / (remaining_capacity - item + 1)) * penalty_factor - (i * priority_factor)\\n \\n return scores\",\n \"objective\": 0.04296,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the remaining capacity and a weighted sum of the index values of the bins, with higher weights given to bins with more capacity. The algorithm will penalize bins at maximum capacity and reward bins with higher remaining capacity. The main steps are as follows:\\n - Calculate the maximum capacity of the bins.\\n - Create an array of scores with the same length as the bins array, initialized to zero.\\n - Iterate over the bins.\\n - If a bin has maximum capacity, assign a penalty score based on the bin's index value.\\n - If a bin has remaining capacity, calculate the weighted capacity by subtracting its capacity from the maximum capacity and multiplying it by a reward factor.\\n - Calculate the score for the bin by summing the weighted capacity and the index value multiplied by the reward factor.\\n - Store the score in the scores array.\\n - Return the scores array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n reward_factor = 100\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i / len(bins))\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_factor\\n index_weight = i * reward_factor\\n scores[i] = weighted_capacity + index_weight\\n \\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity and the current item size, while also considering the cumulative sum of the bins, with bins having a higher cumulative sum being prioritized.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n cumulative_sum = np.cumsum(bins)\\n scores = bins - item + cumulative_sum\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a weighted combination of the remaining capacity and the index value of the bins, with higher weights given to bins with more capacity and lower index values, to encourage the utilization of bins with more space and bins that have not been assigned items yet. The algorithm will also penalize bins at maximum capacity, with a higher penalty factor for bins with lower index values, and reward bins with higher remaining capacity, but with a lower reward factor for bins with higher index values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 10000\\n reward_factor = 100\\n fixed_weight = reward_factor * (1 - (1/len(bins))) # Fixed weight for both remaining_capacity and index\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (1 - (i / len(bins)))\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * fixed_weight\\n index_weight = (len(bins) - i) * fixed_weight\\n scores[i] = weighted_capacity + index_weight\\n \\n return scores\",\n \"objective\": 0.04467,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a weighted combination of the remaining capacity and the index value of the bins, with higher weights given to bins with more capacity and lower index values, to encourage the utilization of bins with more space and bins that have not been assigned items yet. The algorithm will also penalize bins at maximum capacity, with a higher penalty factor for bins with lower index values, and reward bins with higher remaining capacity, but with a lower reward factor for bins with higher index values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 10000\\n reward_factor = 100\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (1 - (i / len(bins)))\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_factor\\n index_weight = (len(bins) - i) * reward_factor\\n scores[i] = weighted_capacity + index_weight\\n \\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, a reward for bins with higher remaining capacity, and a priority for bins with lower index values. The algorithm will also use a modified version of the formula provided in the original algorithm to calculate the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n reward_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = reward_factor / (remaining_capacity - item + 1) - i\\n else:\\n scores[i] = ((1 + ((item + 1) % 2)) / (remaining_capacity - item + 1)) * penalty_factor - i\\n \\n return scores\",\n \"objective\": 0.04548,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and a reward for bins with higher remaining capacity, to encourage the utilization of bins with more space. The algorithm will also prioritize bins with lower index values, to promote the use of bins that have not been assigned items yet.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n reward_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = reward_factor / (remaining_capacity - item + 1) - i\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor - i\\n \\n return scores\",\n \"objective\": 0.04598,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"subtract average capacity divided by the absolute difference between remaining capacity and the average capacity from each bin's score\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n reward_factor = 1000\\n avg_capacity = np.mean(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n scores[i] = (reward_factor / (remaining_capacity - item + 1)) - i - (avg_capacity / np.abs(remaining_capacity - avg_capacity))\\n \\n return scores\",\n \"objective\": 0.05403,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The algorithm first calculates the residual capacities of the bins by subtracting the item size from each bin capacity. Then, it calculates the index weights by raising a sequence of numbers from 0 to the number of bins minus one to the power of a constant value. Next, it computes the scores for each bin by using the residual capacities and the item size in a mathematical expression that includes trigonometric and exponential functions. Finally, it returns the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, np.exp(constant_value))\\n scores = (residual_capacities + np.cos(item / residual_capacities)) / index_weights * (item * residual_capacities) ** np.exp(constant_value)\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n\\n position_index = np.arange(len(bins)) + 1\\n scores = np.where(bins == max_capacity, -position_index * num_bins_used, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the standard deviation of the bin capacities. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the variation in bin capacities. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n std_dev = np.std(bins)\\n \\n scores = np.where(bins == max_capacity, -(np.arange(len(bins)) + 1) * num_bins_used, (max_capacity - bins) * item_weights + std_dev)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins)) * constant_value\\n scores = (item * (np.log(residual_capacities) + np.exp(item * residual_capacities))) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, constant_value=5):\\n residual_capacities = bins - item\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the product between the item size and the residual capacity of the bin, multiplied by the logarithm of the position index of the bin plus a constant value of 4; the square root of the sum of the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity plus the logarithm of the position index of the bin minus a constant value of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (1 / (item * residual_capacities)) * (np.log(4) + 4) + (np.sqrt(item + residual_capacities) / (4 * 4)) + (np.sin(item / residual_capacities) * np.exp((item * residual_capacities) + np.log(4) - 4))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins))\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + 1\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, np.exp(constant_value))\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities) ** np.exp(constant_value)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights, the residual capacities are raised to the power of the item squared, and then multiplied by a constant value before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n scores = (np.log(item) * (residual_capacities ** (item ** 2)) + np.cos(item / residual_capacities)) * constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n\\n position_index = np.arange(len(bins)) + 1\\n scores = np.where(bins == max_capacity, -position_index * num_bins_used, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(residual_capacities) + np.exp(item * residual_capacities))) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, constant_value=5):\\n residual_capacities = bins - item\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins))\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + 1\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the product of the item size and the logarithm of the residual capacity of the bin, multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin; and the square root of the reciprocal of the item size, multiplied by the exponential of the sum of the residual capacity and a constant value, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n indices = np.arange(1, len(residual_capacities) + 1)\\n scores = (item * np.log(residual_capacities) * np.sin(item / residual_capacities) / np.sqrt(indices)) + (np.sqrt(1 / item) * np.exp(residual_capacities + constant_value) ** item)\\n\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights, the residual capacities are raised to the power of the item squared, and then multiplied by a constant value before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n scores = (np.log(item) * (residual_capacities ** (item ** 2)) + np.cos(item / residual_capacities)) * constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n \\n scores = (item * (np.log(residual_capacities) + np.exp(item * residual_capacities))) / np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(residual_capacities) + np.exp(item * residual_capacities))) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, constant_value=5):\\n residual_capacities = bins - item\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins))\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + 1\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the product of the item size and the logarithm of the residual capacity of the bin, multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin; and the square root of the reciprocal of the item size, multiplied by the exponential of the sum of the residual capacity and a constant value, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n indices = np.arange(1, len(residual_capacities) + 1)\\n scores = (item * np.log(residual_capacities) * np.sin(item / residual_capacities) / np.sqrt(indices)) + (np.sqrt(1 / item) * np.exp(residual_capacities + constant_value) ** item)\\n\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights, the residual capacities are raised to the power of the item squared, and then multiplied by a constant value before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n scores = (np.log(item) * (residual_capacities ** (item ** 2)) + np.cos(item / residual_capacities)) * constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (item * (np.log(residual_capacities) + np.exp(item * residual_capacities))) / np.sin(item / residual_capacities)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, constant_value=5):\\n residual_capacities = bins - item\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + 1\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the product of the item size and the logarithm of the residual capacity of the bin, multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin; and the square root of the reciprocal of the item size, multiplied by the exponential of the sum of the residual capacity and a constant value, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n indices = np.arange(1, len(residual_capacities) + 1)\\n scores = (item * np.log(residual_capacities) * np.sin(item / residual_capacities) / np.sqrt(indices)) + (np.sqrt(1 / item) * np.exp(residual_capacities + constant_value) ** item)\\n\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (item * (np.log(residual_capacities) + np.exp(item * residual_capacities))) / np.sin(item / residual_capacities)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, constant_value=5):\\n residual_capacities = bins - item\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n weight = np.mean(bins) # Use the average capacity of the bins as the weight\\n scores = residual_capacities / weight\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the product of the item size and the logarithm of the residual capacity of the bin, multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin; and the square root of the reciprocal of the item size, multiplied by the exponential of the sum of the residual capacity and a constant value, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n indices = np.arange(1, len(residual_capacities) + 1)\\n scores = (item * np.log(residual_capacities) * np.sin(item / residual_capacities) / np.sqrt(indices)) + (np.sqrt(1 / item) * np.exp(residual_capacities + constant_value) ** item)\\n\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (item * (np.log(residual_capacities) + np.exp(item * residual_capacities))) / np.sin(item / residual_capacities)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, constant_value=5):\\n residual_capacities = bins - item\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n weight = np.mean(bins) # Use the average capacity of the bins as the weight\\n scores = residual_capacities / weight\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the product of the item size and the logarithm of the residual capacity of the bin, multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin; and the square root of the reciprocal of the item size, multiplied by the exponential of the sum of the residual capacity and a constant value, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n indices = np.arange(1, len(residual_capacities) + 1)\\n scores = (item * np.log(residual_capacities) * np.sin(item / residual_capacities) / np.sqrt(indices)) + (np.sqrt(1 / item) * np.exp(residual_capacities + constant_value) ** item)\\n\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sine of the ratio between the item size and the residual capacity, divided by the square root of the sum of the item size and the residual capacity, all multiplied by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sin(item / residual_capacities)) / (np.sqrt(item + residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n weight = np.mean(bins) # Use the average capacity of the bins as the weight\\n scores = residual_capacities / weight\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the product of the item size and the logarithm of the residual capacity of the bin, multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin; and the square root of the reciprocal of the item size, multiplied by the exponential of the sum of the residual capacity and a constant value, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n indices = np.arange(1, len(residual_capacities) + 1)\\n scores = (item * np.log(residual_capacities) * np.sin(item / residual_capacities) / np.sqrt(indices)) + (np.sqrt(1 / item) * np.exp(residual_capacities + 5) ** item)\\n\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == np.max(bins), -position_index, (np.max(bins) - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sine of the ratio between the item size and the residual capacity, divided by the square root of the sum of the item size and the residual capacity, all multiplied by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sin(item / residual_capacities)) / (np.sqrt(item + residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1)\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = (bins - np.mean(bins)) / (std_dev + 1)\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n weight = np.mean(bins) # Use the average capacity of the bins as the weight\\n scores = residual_capacities / weight\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == np.max(bins), -position_index, (np.max(bins) - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sine of the ratio between the item size and the residual capacity, divided by the square root of the sum of the item size and the residual capacity, all multiplied by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sin(item / residual_capacities)) / (np.sqrt(item + residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1)\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = (bins - np.mean(bins)) / (std_dev + 1)\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n weight = np.mean(bins) # Use the average capacity of the bins as the weight\\n scores = residual_capacities / weight\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the exponential of the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1e-6) # Adding a small constant\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = np.exp((bins - np.mean(bins)) / (std_dev + 1))\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the exponential of the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1)\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = np.exp((bins - np.mean(bins)) / (std_dev + 1))\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the exponential of the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 10, and multiplied by the cosine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (np.exp(np.log(bins - item)) + np.exp(item * (bins - item)))) / (np.cos(item / (bins - item)) + 10)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (np.log(bins - item) + np.exp(item * (bins - item))) / np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins == np.max(bins), -position_index, (np.max(bins) - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sine of the ratio between the item size and the residual capacity, divided by the square root of the sum of the item size and the residual capacity, all multiplied by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sin(item / residual_capacities)) / (np.sqrt(item + residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1)\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = (bins - np.mean(bins)) / (std_dev + 1)\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. To incentivize the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n index_weights = np.log(np.arange(len(bins)) + 1 + constant_value)\\n scores = remaining_capacities * item_weights / index_weights\\n \\n scores[bins == max_capacity] = -constant_value * np.arange(len(bins))[bins == max_capacity] * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm is to calculate the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. To encourage the utilization of bins with more space and bins that have not been assigned items yet, the algorithm will also introduce a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -constant_value * (i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + constant_value)\\n index_weight = np.log(i + 1 + constant_value)\\n scores[i] = remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity multiplied by the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 2.5. To encourage the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\\n\\n1. Define the constant value as 2.5.\\n2. Find the maximum capacity among the bins.\\n3. Count the number of assigned items in the bins that have a capacity less than the maximum capacity.\\n4. Create an empty array, 'scores', with the same shape as the 'bins' array.\\n5. Iterate over each bin index:\\n - If the bin has the maximum capacity, calculate the score as -constant_value times (the bin index plus 1) times the number of assigned items.\\n - If the bin has a capacity less than the maximum capacity:\\n - Calculate the remaining capacity as the difference between the maximum capacity and the bin capacity.\\n - Calculate the item weight as the difference between the item size and the bin capacity, divided by the absolute difference between the remaining capacity and the item size plus the constant value.\\n - Calculate the index weight as the logarithm of the bin index plus 1 plus the constant value.\\n - Calculate the score as the remaining capacity times the item weight divided by the index weight.\\n6. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2.5\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -constant_value * (i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + constant_value)\\n index_weight = np.log(i + 1 + constant_value)\\n scores[i] = remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. To incentivize the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = remaining_capacities * item_weights / index_weights\\n \\n scores[bins == max_capacity] = -constant_value * np.arange(len(bins))[bins == max_capacity] * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.03169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the remaining capacity divided by the absolute difference between the remaining capacity and the item size, multiplied by the logarithm of the remaining capacity, and subtracted by the position index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.abs((bins - item))) * np.log(bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is to calculate the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the square root of the position index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * (1 / np.abs((bins - item)))) / np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the remaining capacity and the index value of the bins, with higher weights given to bins with more capacity and lower index values, to encourage the utilization of bins with more space and bins that have not been assigned items yet. The algorithm will also penalize bins at maximum capacity, with a higher penalty factor for bins with lower index values, and reward bins with higher remaining capacity. In addition, it will introduce a new factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n penalty_factor = 10000\\n reward_capacity_factor = 100\\n reward_index_factor = 10\\n penalty_item_factor = 1000\\n\\n scores = np.zeros_like(bins, dtype=float)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (i + 1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (len(bins) - i) * reward_index_factor\\n item_weight = item * penalty_item_factor\\n scores[i] = weighted_capacity + index_weight - item_weight\\n\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin based on the inverse of the absolute difference between the remaining capacity and the item size, multiplied by the logarithm of the remaining capacity, and subtract the position index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs((bins - item)) * np.log(bins) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the remaining capacity and the current item size, taking into account the reciprocal of the cumulative sum of bins with a higher remaining capacity, promoting efficient bin usage and minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n reciprocal_cumulative_sum = 1 / np.cumsum(bins)\\n scores = reciprocal_cumulative_sum + item / bins\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the remaining capacity and the current item size, taking into account the reciprocal of the cumulative sum of bins with a higher remaining capacity, promoting efficient bin usage and minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the index value of the bins, and a penalty for bins at maximum capacity, with different weightings for each factor. The algorithm also takes into account the total number of bins used so far, penalizing bins with higher indices to encourage utilization of bins that have not been assigned items yet. The scores are returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n penalty_factor = 10000\\n reward_capacity_factor = 100\\n reward_index_factor = 10\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (i + 1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (len(bins) - i) * reward_index_factor\\n scores[i] = weighted_capacity + index_weight\\n \\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the combination of the remaining capacity, the index value of the bins, penalties for bins at maximum capacity, and rewards for bins with higher remaining capacity, while also considering the cumulative sum of bins and prioritizing bins with lower index values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 5000\\n reward_capacity_factor = 200\\n reward_index_factor = 100\\n cumulative_sum = np.cumsum(bins)\\n\\n scores = (\\n (max_capacity - bins) * reward_capacity_factor / (max_capacity - bins + 1)\\n - bins * penalty_factor\\n + cumulative_sum * reward_index_factor\\n )\\n\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is to calculate the scores for each bin based on a combination of the remaining capacity and the reciprocal of the absolute difference between the remaining capacity and the item size, divided by the square of the index value of the bin. The algorithm will also introduce a penalty factor for bins at maximum capacity, proportional to the item size, to discourage their utilization, and reward bins with higher remaining capacity, with a reward factor inversely proportional to the square root of the index value of the bin. The main steps are as follows:\\n1. Calculate the maximum capacity of the bins.\\n2. Initialize the penalty and reward factors.\\n3. Create an array of scores with the same length as the bins array, initialized to zero.\\n4. Iterate over the bins.\\n a. If a bin has maximum capacity, assign a penalty score based on the item size.\\n b. If a bin has remaining capacity, calculate the reciprocal of the absolute difference between the remaining capacity and the item size.\\n c. Calculate the index weight by dividing 1 by the square of the index value.\\n d. Calculate the score for the bin by multiplying the reciprocal difference, the index weight, and the remaining capacity.\\n e. Store the score in the scores array.\\n5. Return the scores array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n penalty_factor = item\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor\\n else:\\n remaining_capacity = bins[i]\\n reciprocal_difference = 1 / np.abs(remaining_capacity - item)\\n index_weight = 1 / ((i + 1) ** 2)\\n scores[i] = remaining_capacity * reciprocal_difference * index_weight\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm takes into account the remaining capacity, the index value of the bins, penalties for bins at maximum capacity, rewards for bins with higher remaining capacity and smaller item sizes, and combines them using customized formulas and weightings to calculate the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 20000\\n reward_capacity_factor = 1500\\n reward_index_factor = 500\\n reward_smaller_items_factor = 300\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n remaining_capacity = max_capacity - bins\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (np.arange(len(bins), 0, -1)) * reward_index_factor\\n item_weight = (item - bins) * reward_smaller_items_factor\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * ((i + 1) / len(bins)) * num_assigned_items\\n else:\\n scores[i] = weighted_capacity[i] + index_weight[i] + item_weight[i]\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"A new algorithm is proposed where the scores for each bin are calculated based on the remaining capacity and the current item size, considering the square root of the reciprocal of the cumulative sum of bins with a higher remaining capacity, promoting efficient bin usage and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n reciprocal_cumulative_sum = np.sqrt(1 / np.cumsum(bins))\\n scores = reciprocal_cumulative_sum + item / bins\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the remaining capacity, the index value of the bins, and a penalty for bins at maximum capacity. The algorithm will penalize bins at maximum capacity more heavily, reward bins with higher remaining capacity and lower index value, and include a factor that decreases the score for bins that have already been assigned items. The main steps are as follows: \\n- Calculate the maximum capacity of the bins.\\n- Create an array of scores with the same length as the bins array, initialized to zero.\\n- Iterate over the bins.\\n - If a bin has maximum capacity, assign a penalty score based on the bin's index value multiplied by a higher penalty factor.\\n - If a bin has remaining capacity, calculate the weighted capacity by subtracting its capacity from the maximum capacity and multiplying it by a reward factor. Add a penalty for bins with lower index values and a reward for bins with higher remaining capacity.\\n - Subtract a score factor for bins that have already been assigned items, based on the ratio of the remaining capacity to the maximum capacity of the bins.\\n - Calculate the score for the bin by summing the weighted capacity, the index value multiplied by a reward factor, and the score factor.\\n - Store the score in the scores array.\\n- Return the scores array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 5000\\n reward_capacity_factor = 300\\n reward_index_factor = 200\\n score_factor = 100\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -penalty_factor * (i / len(bins))\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * reward_capacity_factor\\n index_weight = (len(bins) - i) * reward_index_factor\\n score_weight = (1 - (bins[i] / max_capacity)) * score_factor\\n scores[i] = weighted_capacity + index_weight - score_weight\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the remaining capacity and the weighted sum of the index values of the bins, with higher weights given to bins with more capacity and lower index values to encourage the utilization of bins with more space and bins that have not been assigned items yet. The algorithm will also penalize bins at maximum capacity, with a higher penalty factor for bins with lower index values, and reward bins with higher remaining capacity, but with a lower reward factor for bins with higher index values. The main steps are as follows:\\n - Calculate the maximum capacity of the bins.\\n - Initialize the penalty and reward factors.\\n - Create an array of scores with the same length as the bins array, initialized to zero.\\n - Iterate over the bins.\\n - If a bin has maximum capacity, assign a penalty score based on the bin's index value.\\n - If a bin has remaining capacity, calculate the weighted capacity by subtracting its capacity from the maximum capacity and multiplying it by the reward factor.\\n - Calculate the index weight by multiplying the index value by the reward factor.\\n - Calculate the score for the bin by summing the weighted capacity and index weight.\\n - Store the score in the scores array.\\n - Return the scores array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -10000 * (1 - (i / len(bins)))\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n weighted_capacity = remaining_capacity * 100\\n index_weight = i * 100\\n scores[i] = weighted_capacity + index_weight\\n \\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Calculate the scores for each bin based on the inverse of the absolute difference between the remaining capacity and the item size, multiplied by the logarithm of the remaining capacity, and subtract the position index of the bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / np.abs((bins - item)) - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm takes into account the ratio between the item size and the remaining capacity of the bins, considering both the maximum capacity and the current capacity of each bin, and assigning a score based on these values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n current_capacity = bins - item\\n scores = (item / current_capacity) * (current_capacity / max_capacity)\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the exponential of the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1e-6) # Adding a small constant\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = np.exp((bins - np.mean(bins)) / (std_dev + 1))\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the exponential of the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1)\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = np.exp((bins - np.mean(bins)) / (std_dev + 1))\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the average capacity, the item size, and the position index of each bin. It penalizes bins that are close to the average capacity, incentivizes the utilization of bins with more space, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n position_index = np.arange(len(bins)) + 1\\n\\n scores = np.where(bins >= avg_capacity, -position_index, (avg_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the exponential of the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 10, and multiplied by the cosine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item * (np.exp(np.log(bins - item)) + np.exp(item * (bins - item)))) / (np.cos(item / (bins - item)) + 10)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins)))\\n scores = residual_capacities / index_weights\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (np.log(bins - item) + np.exp(item * (bins - item))) / np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))))\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** 3 + np.cos(item / residual_capacities)) / 5 * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the logarithm of the residual capacity, and the product of the item size and the residual capacity, all divided by the position index of each bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n index_weights = np.ones(len(bins))\\n scores = (item * (np.log(bins - item) + np.exp(item * (bins - item)))) / index_weights * np.sin(item / (bins - item))\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sine of the ratio between the item size and the residual capacity, divided by the square root of the sum of the item size and the residual capacity, all multiplied by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sin(item / residual_capacities)) / (np.sqrt(item + residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square root of the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 3, and added by the exponential function of the product of the item size and the residual capacity multiplied by the cosine of the item size squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(residual_capacities) * np.sin(item / residual_capacities)) / (np.log(np.arange(len(bins))) + 3) + np.exp(item * residual_capacities * np.cos(item**2))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the position index of each bin, and a penalty term based on the standard deviation of the remaining capacities of the bins. It incentivizes the utilization of bins with more space, penalizes bins with higher standard deviation in their remaining capacities, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n item_weights = (item - bins) / (np.abs(item - bins) + 1)\\n position_index = np.arange(len(bins)) + 1\\n \\n std_dev = np.std(bins)\\n std_dev_penalty = (bins - np.mean(bins)) / (std_dev + 1)\\n \\n scores = np.where(bins == max_capacity, -position_index, (max_capacity - bins) * item_weights + position_index - std_dev_penalty)\\n \\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = np.log(np.arange(len(bins)) + constant_value)\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) / index_weights + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin plus a constant value of 3, and subtracted by the logarithm of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)) + constant_value)\\n scores = (residual_capacities * np.sin(item / residual_capacities)) / index_weights - np.log(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i+1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n index_weights = np.arange(len(bins))\\n scores[i] = remaining_capacity * item_weights[i] / index_weights[i]\\n \\n scores[bins == max_capacity] = -np.arange(len(bins))[bins == max_capacity] * num_bins_used\\n \\n return scores\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = np.divide((item - bins), np.abs(bins - item))\\n indices = np.arange(len(bins))\\n \\n scores = np.zeros_like(bins, dtype=float)\\n mask = bins == max_capacity\\n scores[mask] = -np.multiply(np.arange(len(bins)), num_bins_used)[mask]\\n \\n remaining_capacity = max_capacity - bins\\n scores[~mask] = np.divide(np.multiply(remaining_capacity, item_weights), indices)[~mask]\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin plus a constant value of 3, and subtracted by the logarithm of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n \\n # Simplify calculation of residual_capacities\\n residual_capacities = bins - item\\n \\n # Simplify calculation of index_weights\\n index_weights = np.sqrt(np.arange(len(bins)))\\n \\n scores = (residual_capacities * np.sin(item / residual_capacities)) / index_weights - np.log(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.02455,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the remaining capacity and a weighted factor of the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n scores = remaining_capacities * item_weights / (1 + constant_value)\\n \\n scores[bins == max_capacity] = -constant_value * np.arange(len(bins))[bins == max_capacity] * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.02576,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the square root of the position index of the bin plus a constant value of 1. To incentivize the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n index_weights = np.sqrt(np.arange(len(bins)) + constant_value)\\n scores = remaining_capacities * item_weights / index_weights\\n \\n scores[bins == max_capacity] = -constant_value * np.sqrt(np.arange(len(bins))[bins == max_capacity]) * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.02616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. To incentivize the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n index_weights = np.log(np.arange(len(bins)) + 1 + constant_value)\\n scores = remaining_capacities * item_weights / index_weights\\n \\n scores[bins == max_capacity] = -constant_value * np.arange(len(bins))[bins == max_capacity] * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity multiplied by the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 2.5. To encourage the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\\n\\n1. Define the constant value as 2.5.\\n2. Find the maximum capacity among the bins.\\n3. Count the number of assigned items in the bins that have a capacity less than the maximum capacity.\\n4. Create an empty array, 'scores', with the same shape as the 'bins' array.\\n5. Iterate over each bin index:\\n - If the bin has the maximum capacity, calculate the score as -constant_value times (the bin index plus 1) times the number of assigned items.\\n - If the bin has a capacity less than the maximum capacity:\\n - Calculate the remaining capacity as the difference between the maximum capacity and the bin capacity.\\n - Calculate the item weight as the difference between the item size and the bin capacity, divided by the absolute difference between the remaining capacity and the item size plus the constant value.\\n - Calculate the index weight as the logarithm of the bin index plus 1 plus the constant value.\\n - Calculate the score as the remaining capacity times the item weight divided by the index weight.\\n6. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + 2.5)\\n index_weight = np.log(i + 1 + 2.5)\\n scores[i] = remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm is to calculate the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. To encourage the utilization of bins with more space and bins that have not been assigned items yet, the algorithm will also introduce a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -constant_value * (i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + constant_value)\\n index_weight = np.log(i + 1 + constant_value)\\n scores[i] = remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02707,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the remaining capacity and a weighted factor of the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n index_weights = np.log(np.arange(len(bins)) + 1 + constant_value)\\n scores = remaining_capacities * item_weights * (1 + index_weights) / (1 + constant_value)\\n \\n scores[bins == max_capacity] = -constant_value * np.arange(len(bins))[bins == max_capacity] * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm is to calculate the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the sum of the remaining capacity and the item size plus a constant value of 1. To encourage the utilization of bins with more space and bins that have not been assigned items yet, the algorithm will also introduce a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -constant_value * (i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + constant_value)\\n size_weight = np.log(remaining_capacity + item + constant_value)\\n scores[i] = remaining_capacity * item_weight / size_weight\\n \\n return scores\",\n \"objective\": 0.02807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, and the position index of each bin, while also penalizing bins at maximum capacity and incentivizing the utilization of bins with more space and bins that have not been assigned items yet. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n constant_value = 3\\n \\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i+1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + constant_value)\\n index_weight = np.log(i+1) + constant_value\\n scores[i] = remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, with the constant value multiplied by a scaling factor determined by the ratio of the remaining capacity to the maximum capacity, divided by the logarithm of the bin index plus a constant value of 1.5.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1.5\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -constant_value * (i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n scaling_factor = remaining_capacity / max_capacity\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + constant_value)\\n index_weight = np.log(i + 1 + constant_value)\\n scores[i] = constant_value * scaling_factor * remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity multiplied by the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 2.5. To encourage the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\\n\\n1. Define the constant value as 2.5.\\n2. Find the maximum capacity among the bins.\\n3. Count the number of assigned items in the bins that have a capacity less than the maximum capacity.\\n4. Create an empty array, 'scores', with the same shape as the 'bins' array.\\n5. Iterate over each bin index:\\n - If the bin has the maximum capacity, calculate the score as -constant_value times (the bin index plus 1) times the number of assigned items.\\n - If the bin has a capacity less than the maximum capacity:\\n - Calculate the remaining capacity as the difference between the maximum capacity and the bin capacity.\\n - Calculate the item weight as the difference between the item size and the bin capacity, divided by the absolute difference between the remaining capacity and the item size plus the constant value.\\n - Calculate the index weight as the logarithm of the bin index plus 1 plus the constant value.\\n - Calculate the score as the remaining capacity times the item weight divided by the index weight.\\n6. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2.5\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -constant_value * (i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + constant_value)\\n index_weight = np.log(i + 1 + constant_value)\\n scores[i] = remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm is to calculate the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin squared plus a constant value of 2. To encourage the utilization of bins with more space and bins that have not been assigned items yet, the algorithm will also introduce a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The main steps are as follows:\\n\\n1. Set a constant value of 2.\\n2. Find the maximum capacity of the bins.\\n3. Count the number of bins that have not been fully utilized yet.\\n4. Create an empty array of scores with the same size as the bins array.\\n5. Iterate through each bin:\\n a. If the bin has reached its maximum capacity:\\n - Assign a negative score to the bin, calculated by multiplying the constant value, the position index of the bin plus 1, and the number of assigned items.\\n b. If the bin still has remaining capacity:\\n - Calculate the remaining capacity of the bin.\\n - Calculate the item weight, which is the ratio between the difference of the item size and the remaining capacity plus the constant value.\\n - Calculate the index weight, which is the logarithm of the position index of the bin plus 1 squared plus the constant value.\\n - Multiply the remaining capacity, the item weight, and the index weight to get the score for the bin.\\n6. Return the array of scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i + 1) * num_assigned_items\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n item_weight = (item - bins[i]) / (np.abs(remaining_capacity - item) + 1)\\n index_weight = np.log((i + 1)**2 + 1)\\n scores[i] = remaining_capacity * item_weight / index_weight\\n \\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm aims to optimize bin utilization and minimize the number of used bins by calculating scores based on various factors. It takes into account the remaining capacity of each bin, the current item size, and the position index of each bin, while also penalizing bins at maximum capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i+1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n scores[i] = remaining_capacity / (item - bins[i]) * (np.log(i+1) + 1)\\n \\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the square root of the position index of the bin plus a constant value of 1. To incentivize the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n index_weights = np.ones(len(bins)) # Simplified - assigning equal weights to all bins\\n scores = remaining_capacities * item_weights / index_weights\\n \\n scores[bins == max_capacity] = -constant_value * np.sqrt(np.arange(len(bins))[bins == max_capacity]) * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and double the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. To incentivize the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / ((np.abs(remaining_capacities - (2 * item)) + constant_value))\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = remaining_capacities * item_weights / index_weights\\n \\n scores[bins == max_capacity] = -constant_value * np.arange(len(bins))[bins == max_capacity] * num_assigned_items\\n \\n return scores\",\n \"objective\": 0.03059,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the product of the remaining capacity and the inverse of the absolute difference between the remaining capacity and the item size, divided by the logarithm of the position index of the bin plus a constant value of 1. To incentivize the utilization of bins with more space and bins that have not been assigned items yet, the algorithm introduces a factor that considers the sizes of the items in the bins, penalizing bins with smaller item sizes. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 1\\n max_capacity = np.max(bins)\\n num_assigned_items = np.count_nonzero(bins < max_capacity)\\n \\n remaining_capacities = max_capacity - bins\\n item_weights = (item - bins) / (np.abs(remaining_capacities - item) + constant_value)\\n index_weights = np.arange(len(bins)) + 1 + constant_value\\n scores = remaining_capacities * item_weights / index_weights\\n \\n scores[bins == max_capacity] = -constant_value * np.arange(len(bins))[bins == max_capacity] * num_assigned_items\\n\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = np.log(constant_value)\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) / index_weights + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i+1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n scores[i] = remaining_capacity * item_weights[i]\\n \\n scores[bins == max_capacity] = -(np.arange(len(bins))[bins == max_capacity] + 1) * num_bins_used\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the residual capacity of the bin and the sine of the ratio between the item size and the residual capacity, divided by the cube root of the position index of the bin plus a constant value of 2, and multiplied by the exponential function of the product of the item size and the residual capacity minus the logarithm of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are used, and the indexing weights are squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the ratio of the remaining capacity to the item size. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = np.divide((item - bins), np.abs(bins - item))\\n ratio = np.divide(bins, item)\\n indices = np.arange(len(bins))\\n \\n scores = np.zeros_like(bins, dtype=float)\\n mask = bins == max_capacity\\n scores[mask] = -np.multiply(np.arange(len(bins)), num_bins_used)[mask]\\n \\n remaining_capacity = max_capacity - bins\\n scores[~mask] = np.divide(np.multiply(remaining_capacity, item_weights), indices)[~mask]\\n \\n scores = scores + ratio * item\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.log(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities ** (item ** 2) + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin plus a constant value of 3, and subtracted by the logarithm of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)) + 3)\\n scores = (residual_capacities * np.sin(item / residual_capacities))\\n scores /= index_weights\\n scores -= np.log(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are replaced with the square root and the logarithm functions, respectively, and the indexing weights are squared before being used in the score calculation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sqrt(item / residual_capacities)) / index_weights * (item * residual_capacities - np.log(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on a combination of the item size and the residual capacity of the bin, using mathematical functions like square root, cube root, cosine, exponential, and logarithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.log(np.arange(len(bins)) + constant_value)\\n scores = (np.sqrt(item - residual_capacities) / index_weights) + (np.exp(item - residual_capacities) * np.cos(item / residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the inverse of the residual capacities, where the exponential and cosine functions are used, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, 3)\\n scores = (1 / residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the product between the item size and the residual capacity of the bin, divided by the logarithm of the position index of the bin plus a constant value of 2; the cube root of the difference between the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the cosine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity minus the logarithm of the position index of the bin plus a constant value of 3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.log(np.arange(len(bins)) + constant_value)\\n scores = (np.sqrt(item * residual_capacities) / index_weights) + (np.cbrt(item - residual_capacities) / (index_weights * constant_value)) + (np.cos(item / residual_capacities) * np.exp((item * residual_capacities) - np.log(index_weights) + constant_value))\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the product between the item size and the residual capacity of the bin, divided by the logarithm of the position index of the bin plus a constant value of 2; the cube root of the difference between the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the cosine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity minus the logarithm of the position index of the bin plus a constant value of 3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n \\n index_weights = np.full(len(bins), constant_value) # Simplified component\\n \\n scores = (np.sqrt(item * residual_capacities) / index_weights) + (np.cbrt(item - residual_capacities) / (index_weights * constant_value)) + (np.cos(item / residual_capacities) * np.exp((item * residual_capacities) - np.log(index_weights) + constant_value))\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the cosine and logarithmic functions are used, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.cos(item / residual_capacities)) / index_weights * (item * residual_capacities - np.log10(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original score function, where the logarithmic function is removed and the residual capacities are squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.cos(item / residual_capacities)) / index_weights * (item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, respectively, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = (np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the remaining capacity and the logarithm of the bin index plus a constant value of 2, divided by the cosine of the ratio between the item size and the remaining capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n remaining_capacities = bins - item\\n index_weights = np.log(np.arange(len(bins)) + 1 + constant_value)\\n scores = (remaining_capacities * index_weights) / np.cos(item / remaining_capacities)\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i+1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n index_weights = np.arange(len(bins))\\n scores[i] = remaining_capacity * item_weights[i] / index_weights[i]\\n \\n scores[bins == max_capacity] = -np.arange(len(bins))[bins == max_capacity] * num_bins_used\\n \\n return scores\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = np.divide((item - bins), np.abs(bins - item))\\n indices = np.arange(len(bins))\\n \\n scores = np.zeros_like(bins, dtype=float)\\n mask = bins == max_capacity\\n scores[mask] = -np.multiply(np.arange(len(bins)), num_bins_used)[mask]\\n \\n remaining_capacity = max_capacity - bins\\n scores[~mask] = np.divide(np.multiply(remaining_capacity, item_weights), indices)[~mask]\\n \\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It will penalize bins at maximum capacity and incentivize the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. Additionally, it will also take into account the distance between each bin's index and the index of the last assigned bin to avoid clustering of assigned bins. The algorithm will assign scores to each bin and return an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n \\n scores = np.zeros_like(bins, dtype=float)\\n last_assigned_index = -1\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -(i+1) * num_bins_used\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n distance_factor = np.abs(i - last_assigned_index)\\n scores[i] = remaining_capacity * item_weights[i] / (distance_factor + 1)\\n \\n scores[bins == max_capacity] = -(np.arange(len(bins))[bins == max_capacity] + 1) * num_bins_used\\n \\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin plus a constant value of 3, and subtracted by the logarithm of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n \\n # Simplify calculation of residual_capacities\\n residual_capacities = bins - item\\n \\n # Simplify calculation of index_weights\\n index_weights = np.sqrt(np.arange(len(bins)))\\n \\n scores = (residual_capacities * np.sin(item / residual_capacities)) / index_weights - np.log(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.02455,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = np.log(constant_value)\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) / index_weights + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, respectively, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + constant_value\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n \\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n scores = np.where(bins == max_capacity, -(np.arange(len(bins)) + 1) * num_bins_used, (max_capacity - bins) * item_weights)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the product between the item size and the residual capacity of the bin, multiplied by the logarithm of the position index of the bin plus a constant value of 4; the square root of the sum of the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity plus the logarithm of the position index of the bin minus a constant value of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = (1 / (item * residual_capacities)) * (np.log(index_weights) + constant_value) + (np.sqrt(item + residual_capacities) / (index_weights * constant_value)) + (np.sin(item / residual_capacities) * np.exp((item * residual_capacities) + np.log(index_weights) - constant_value))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm calculates the scores for each bin by taking the product of the inverse of the residual capacities of the bins raised to the power of the logarithm of the item size, divided by the square of the position index of the bin plus a constant value of 5, and added by the square root of the exponential function of the product of the item size and the residual capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (1 / residual_capacities) ** np.log(item) / (index_weights + constant_value**2) + np.sqrt(np.exp(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are used, and the indexing weights are squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the square root of the item size and the residual capacity, divided by the cube root of the position index of the bin plus a constant value of 2, and added by the exponential function of the cosine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (np.sqrt(item * residual_capacities) / index_weights) + np.exp(np.cos(item / residual_capacities))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the ratio of the remaining capacity to the item size. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = np.divide((item - bins), np.abs(bins - item))\\n ratio = np.divide(bins, item)\\n indices = np.arange(len(bins))\\n \\n scores = np.zeros_like(bins, dtype=float)\\n mask = bins == max_capacity\\n scores[mask] = -np.multiply(np.arange(len(bins)), num_bins_used)[mask]\\n \\n remaining_capacity = max_capacity - bins\\n scores[~mask] = np.divide(np.multiply(remaining_capacity, item_weights), indices)[~mask]\\n \\n scores = scores + ratio * item\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.log(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities ** (item ** 2) + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original score function, where the residual capacities and item sizes are raised to the power of the square root of the constant value before being used in the score calculation. The index weights are also modified to be the square root of the constant value multiplied by the range of the bins added to the constant value, all raised to the power of the square root of the constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_sqrt = np.sqrt(residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_sqrt * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_sqrt + np.cos(item_sqrt / residual_capacities_sqrt)) / index_weights) * ((item_sqrt * residual_capacities_sqrt) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm takes into account the square root of the item size and residual capacities of the bins before calculating the score. It also modifies the index weights based on the square root of the constant value and the range of the bins, all raised to the power of the square root of the constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_sqrt = np.sqrt(residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_value * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_sqrt + np.sin(item_sqrt / residual_capacities_sqrt)) / index_weights) * ((item_sqrt * residual_capacities_sqrt) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin plus a constant value of 3, and subtracted by the logarithm of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)) + 3)\\n scores = (residual_capacities * np.sin(item / residual_capacities))\\n scores /= index_weights\\n scores -= np.log(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are replaced with the square root and the logarithm functions, respectively, and the indexing weights are squared before being used in the score calculation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sqrt(item / residual_capacities)) / index_weights * (item * residual_capacities - np.log(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the following factors: the logarithm of the item size divided by the square root of the residual capacity of the bin, multiplied by the exponential of the position index of the bin; the difference between the item size and the residual capacity divided by the square root of the product of the position index of the bin and a constant value of 2; and the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n \\n index_weights = np.exp(np.arange(len(bins))) # Exponential component\\n \\n scores = (np.log(item) / np.sqrt(residual_capacities) * index_weights) + ((item - residual_capacities) / (np.sqrt(constant_value) * np.sqrt(index_weights))) + (np.sin(item / residual_capacities) * np.exp(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on a combination of the item size and the residual capacity of the bin, using mathematical functions like square root, cube root, cosine, exponential, and logarithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.log(np.arange(len(bins)) + constant_value)\\n scores = (np.sqrt(item - residual_capacities) / index_weights) + (np.exp(item - residual_capacities) * np.cos(item / residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the inverse of the residual capacities, where the exponential and cosine functions are used, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, 3)\\n scores = (1 / residual_capacities + np.cos(item / residual_capacities)) * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.01248,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the item size, the residual capacity, and the position index of the bin, using mathematical functions such as logarithms, exponentials, and trigonometric functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value_1 = 2\\n constant_value_2 = 3\\n residual_capacities = bins - item\\n index_weights = np.log(np.arange(len(bins)) + constant_value_1)\\n scores = (np.sqrt(item * residual_capacities) / (index_weights * constant_value_2)) + (np.cos(item / residual_capacities) * np.exp((item * residual_capacities) - np.log(index_weights) + constant_value_1))\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on a combination of the exponential function of the product of the item size and the residual capacity, the square root of the index weights, and the cosine of the ratio between the item size and the residual capacity, all divided by a constant value of 3, and multiplied by the square of the natural logarithm of the sum of the item size and the residual capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.sqrt(constant_value * np.arange(len(bins)))\\n scores = (np.exp(item * residual_capacities) * np.cos(item / residual_capacities)) / constant_value * np.log(item + residual_capacities) ** 2\\n \\n return scores\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the cosine and logarithmic functions are used, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.cos(item / residual_capacities)) / index_weights * (item * residual_capacities - np.log10(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = np.log(constant_value)\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) / index_weights + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the difference between the item size and the residual capacity of the bin, multiplied by the square root of the position index of the bin, divided by the exponential of the product between the item size and the residual capacity; the log of the item size divided by the square root of the residual capacity of the bin, multiplied by the difference between the item size and the residual capacity divided by the square root of the product of the position index of the bin and a constant value; and the square of the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.array(range(len(bins))) + 1)\\n scores = (1 / np.abs(item - residual_capacities) * np.sqrt(index_weights) / np.exp(item * residual_capacities)) + (np.log(item) / np.sqrt(residual_capacities) * (item - residual_capacities) / (np.sqrt(index_weights) * np.sqrt(constant_value))) + ((np.sin(item / residual_capacities) ** 2) * np.exp(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, respectively, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + constant_value\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the standard deviation of the bin capacities. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the variation in bin capacities. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n \\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n std_dev = np.std(bins)\\n \\n scores = np.where(bins == max_capacity, -(np.arange(len(bins)) + 1) * num_bins_used, (max_capacity - bins) * item_weights + std_dev)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the product between the item size and the residual capacity of the bin, multiplied by the logarithm of the position index of the bin plus a constant value of 4; the square root of the sum of the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity plus the logarithm of the position index of the bin minus a constant value of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = (1 / (item * residual_capacities)) * (np.log(index_weights) + constant_value) + (np.sqrt(item + residual_capacities) / (index_weights * constant_value)) + (np.sin(item / residual_capacities) * np.exp((item * residual_capacities) + np.log(index_weights) - constant_value))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = (np.array(range(len(bins))) ** 2) + bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are used, and the indexing weights are squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the square root of the item size and the residual capacity, divided by the cube root of the position index of the bin plus a constant value of 2, and added by the exponential function of the cosine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (np.sqrt(item * residual_capacities) / index_weights) + np.exp(np.cos(item / residual_capacities))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the ratio of the remaining capacity to the item size. It also penalizes bins at maximum capacity and incentivizes the utilization of bins with more space and bins that have not been assigned items yet by considering the sizes of the items in the bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n item_weights = np.divide((item - bins), np.abs(bins - item))\\n ratio = np.divide(bins, item)\\n indices = np.arange(len(bins))\\n \\n scores = np.zeros_like(bins, dtype=float)\\n mask = bins == max_capacity\\n scores[mask] = -np.multiply(np.arange(len(bins)), num_bins_used)[mask]\\n \\n remaining_capacity = max_capacity - bins\\n scores[~mask] = np.divide(np.multiply(remaining_capacity, item_weights), indices)[~mask]\\n \\n scores = scores + ratio * item\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.log(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities ** (item ** 2) + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original score function, where the residual capacities and item sizes are raised to the power of the square root of the constant value before being used in the score calculation. The index weights are also modified to be the square root of the constant value multiplied by the range of the bins added to the constant value, all raised to the power of the square root of the constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_sqrt = np.sqrt(residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_sqrt * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_sqrt + np.cos(item_sqrt / residual_capacities_sqrt)) / index_weights) * ((item_sqrt * residual_capacities_sqrt) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm takes into account the square root of the item size and residual capacities of the bins before calculating the score. It also modifies the index weights based on the square root of the constant value and the range of the bins, all raised to the power of the square root of the constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_sqrt = np.sqrt(residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_value * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_sqrt + np.sin(item_sqrt / residual_capacities_sqrt)) / index_weights) * ((item_sqrt * residual_capacities_sqrt) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the residual capacity of the bin multiplied by the sine of the ratio between the item size and the residual capacity, divided by the square root of the position index of the bin plus a constant value of 3, and subtracted by the logarithm of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)) + 3)\\n scores = (residual_capacities * np.sin(item / residual_capacities))\\n scores /= index_weights\\n scores -= np.log(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the standard deviation of the bin capacities. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the variation in bin capacities. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n \\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n std_dev = np.std(bins)\\n \\n scores = np.where(bins == max_capacity, -(np.arange(len(bins)) + 1), (max_capacity - bins) * item_weights + std_dev)\\n \\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)) + constant_value)\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the standard deviation of the bin capacities. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the variation in bin capacities. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n \\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n std_dev = np.std(bins)\\n \\n scores = np.where(bins == max_capacity, -num_bins_used, (max_capacity - bins) * item_weights + std_dev)\\n \\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are replaced with the square root and the logarithm functions, respectively, and the indexing weights are squared before being used in the score calculation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sqrt(item / residual_capacities)) / index_weights * (item * residual_capacities - np.log(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the effect of the residual capacities and focuses more on the item size. It uses the logarithmic function to transform the residual capacities before calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_log = np.log(1+residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_sqrt * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_log + np.cos(item_sqrt / residual_capacities_log)) / index_weights) * ((item_sqrt * residual_capacities_log) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the difference between the item size and the residual capacity of the bin, multiplied by the square root of the position index of the bin, divided by the exponential of the product between the item size and the residual capacity; the log of the item size divided by the square root of the residual capacity of the bin, multiplied by the difference between the item size and the residual capacity divided by the square root of the product of the position index of the bin and a constant value; and the square of the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.array(range(len(bins))) + 1)\\n scores = (1 / np.abs(item - residual_capacities) * np.sqrt(index_weights) / np.exp(item * residual_capacities)) + (np.log(item) / np.sqrt(residual_capacities) * (item - residual_capacities) / (np.sqrt(index_weights) * np.sqrt(constant_value))) + ((np.sin(item / residual_capacities) ** 2) * np.exp(item * residual_capacities))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm uses a modified version of the original score function where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, and the indexing weights are squared before being used in the score calculation. Additionally, a penalty term is introduced that penalizes bins with higher residual capacities, aiming to promote more balanced bin utilization.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value)\\n penalty_term = 1 - np.square(1 - (residual_capacities / np.max(residual_capacities)))\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities)) - penalty_term\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, respectively, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + constant_value\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the standard deviation of the bin capacities. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the variation in bin capacities. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n std_dev = np.std(bins)\\n \\n scores = np.where(bins == max_capacity, -(np.arange(len(bins)) + 1) * num_bins_used, (max_capacity - bins) * item_weights + std_dev)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the product between the item size and the residual capacity of the bin, multiplied by the logarithm of the position index of the bin plus a constant value of 4; the square root of the sum of the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity plus the logarithm of the position index of the bin minus a constant value of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = (1 / (item * residual_capacities)) * (np.log(index_weights) + constant_value) + (np.sqrt(item + residual_capacities) / (index_weights * constant_value)) + (np.sin(item / residual_capacities) * np.exp((item * residual_capacities) + np.log(index_weights) - constant_value))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = (np.array(range(len(bins))) ** 2) + bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are used, and the indexing weights are squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the square root of the item size and the residual capacity, divided by the cube root of the position index of the bin plus a constant value of 2, and added by the exponential function of the cosine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (np.sqrt(item * residual_capacities) / index_weights) + np.exp(np.cos(item / residual_capacities))\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, np.exp(constant_value))\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities) ** np.exp(constant_value)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.log(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities ** (item ** 2) + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 5 before being used in the score calculation. Additionally, instead of using np.sin, we will use np.cos for the score calculation. Lastly, we will add a small constant_value to the scores to avoid division by zero.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 5\\n scores = (residual_capacities + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities) + constant_value\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original score function, where the residual capacities and item sizes are raised to the power of the square root of the constant value before being used in the score calculation. The index weights are also modified to be the square root of the constant value multiplied by the range of the bins added to the constant value, all raised to the power of the square root of the constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_sqrt = np.sqrt(residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_sqrt * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_sqrt + np.cos(item_sqrt / residual_capacities_sqrt)) / index_weights) * ((item_sqrt * residual_capacities_sqrt) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm takes into account the square root of the item size and residual capacities of the bins before calculating the score. It also modifies the index weights based on the square root of the constant value and the range of the bins, all raised to the power of the square root of the constant value.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_sqrt = np.sqrt(residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_value * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_sqrt + np.sin(item_sqrt / residual_capacities_sqrt)) / index_weights) * ((item_sqrt * residual_capacities_sqrt) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"My new algorithm reduces the effect of the residual capacities and focuses more on the item size. It uses the logarithmic function to transform the residual capacities before calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_log = np.log(1+residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_sqrt * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_log + np.cos(item_sqrt / residual_capacities_log)) / index_weights) * ((item_sqrt * residual_capacities_log) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n\\n position_index = np.arange(len(bins)) + 1\\n scores = np.where(bins == max_capacity, -position_index * num_bins_used, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm uses a modified version of the original score function where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, and the indexing weights are squared before being used in the score calculation. Additionally, a penalty term is introduced that penalizes bins with higher residual capacities, aiming to promote more balanced bin utilization.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value)\\n penalty_term = 1 - np.square(1 - (residual_capacities / np.max(residual_capacities)))\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities)) - penalty_term\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, respectively, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + constant_value\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the standard deviation of the bin capacities. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the variation in bin capacities. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n std_dev = np.std(bins)\\n \\n scores = np.where(bins == max_capacity, -(np.arange(len(bins)) + 1) * num_bins_used, (max_capacity - bins) * item_weights + std_dev)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.cbrt(np.arange(len(bins)) + constant_value)\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the product between the item size and the residual capacity of the bin, multiplied by the logarithm of the position index of the bin plus a constant value of 4; the square root of the sum of the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity plus the logarithm of the position index of the bin minus a constant value of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = (1 / (item * residual_capacities)) * (np.log(index_weights) + constant_value) + (np.sqrt(item + residual_capacities) / (index_weights * constant_value)) + (np.sin(item / residual_capacities) * np.exp((item * residual_capacities) + np.log(index_weights) - constant_value))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins))\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are used, and the indexing weights are squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, np.exp(constant_value))\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities) ** np.exp(constant_value)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights, the residual capacities are raised to the power of the item squared, and then multiplied by a constant value before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n scores = (np.log(item) * (residual_capacities ** (item ** 2)) + np.cos(item / residual_capacities)) * constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.log(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 5 before being used in the score calculation. Additionally, instead of using np.sin, we will use np.cos for the score calculation. Lastly, we will add a small constant_value to the scores to avoid division by zero.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 5\\n scores = (residual_capacities + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities) + constant_value\\n \\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The algorithm first calculates the residual capacities of the bins by subtracting the item size from each bin capacity. Then, it calculates the index weights by raising a sequence of numbers from 0 to the number of bins minus one to the power of a constant value. Next, it computes the scores for each bin by using the residual capacities and the item size in a mathematical expression that includes trigonometric and exponential functions. Finally, it returns the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, np.exp(constant_value))\\n scores = (residual_capacities + np.cos(item / residual_capacities)) / index_weights * (item * residual_capacities) ** np.exp(constant_value)\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm reduces the effect of the residual capacities and focuses more on the item size. It uses the logarithmic function to transform the residual capacities before calculating the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n item_sqrt = np.sqrt(item)\\n residual_capacities_log = np.log(1+residual_capacities)\\n constant_sqrt = np.sqrt(constant_value)\\n index_weights = (constant_sqrt * np.sqrt(np.array(range(len(bins))) + constant_value)) ** constant_sqrt\\n scores = ((residual_capacities_log + np.cos(item_sqrt / residual_capacities_log)) / index_weights) * ((item_sqrt * residual_capacities_log) ** constant_sqrt)\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the square of the residual capacity of the bin multiplied by the cosine of the ratio between the item size and the residual capacity, divided by the logarithm of the position index of the bin plus a constant value of 4, and added by the exponential function of the product of the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (residual_capacities**2 * np.cos(item / residual_capacities)) + np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, and the position index of each bin. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the position index of bins. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n\\n position_index = np.arange(len(bins)) + 1\\n scores = np.where(bins == max_capacity, -position_index * num_bins_used, (max_capacity - bins) * item_weights + position_index)\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the sum of the following factors: the square root of the item size divided by the logarithm of the residual capacity of the bin, multiplied by the exponent of the product between the item size and the residual capacity; the cosine of the ratio between the item size and the residual capacity, multiplied by the natural logarithm of the product of the item size and the residual capacity divided by the position index of the bin; and the reciprocal of the item size, multiplied by the square root of the sum of the residual capacity and a constant value.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n residual_capacities = bins - item\\n scores = (np.sqrt(item) / np.log(residual_capacities) * np.exp(item * residual_capacities)) + (np.cos(item / residual_capacities) * np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins)))) ** 2\\n scores = residual_capacities / index_weights\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithmic and square root functions are replaced with the hyperbolic tangent and the exponential functions, respectively, and the indexing weights are cubed before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.array(range(len(bins))) + constant_value\\n scores = (residual_capacities + np.tanh(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities - np.log(item * residual_capacities))\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 3, and the index_weights are raised to the power of 3 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 3\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the remaining capacity, the item size, the number of used bins, the position index of each bin, and the standard deviation of the bin capacities. It penalizes bins at maximum capacity, incentivizes the utilization of bins with more space and bins that have not been assigned items yet, and considers the variation in bin capacities. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n num_bins_used = len(bins) - np.count_nonzero(bins == max_capacity)\\n\\n item_weights = (item - bins) / (np.abs(bins - item) + 1)\\n std_dev = np.std(bins)\\n \\n scores = np.where(bins == max_capacity, -(np.arange(len(bins)) + 1) * num_bins_used, (max_capacity - bins) * item_weights + std_dev)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the difference between the exponential of the product of the item size and the residual capacity and the logarithm of the sum of the item size and the residual capacity, all divided by the cube root of the position index of the bin plus a constant value of 5, and multiplied by the sine of the ratio between the item size and the residual capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, constant_value=5):\\n residual_capacities = bins - item\\n index_weights = np.arange(len(bins)) + constant_value\\n scores = (np.exp(item * residual_capacities) - np.log(item + residual_capacities)) / index_weights * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm calculates the scores for each bin based on the sum of the following factors: the reciprocal of the product between the item size and the residual capacity of the bin, multiplied by the logarithm of the position index of the bin plus a constant value of 4; the square root of the sum of the item size and the residual capacity, divided by the product of the position index of the bin and the constant value; the sine of the ratio between the item size and the residual capacity, multiplied by the exponential of the product between the item size and the residual capacity plus the logarithm of the position index of the bin minus a constant value of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 4\\n residual_capacities = bins - item\\n index_weights = constant_value\\n scores = (1 / (item * residual_capacities)) * (np.log(index_weights) + constant_value) + (np.sqrt(item + residual_capacities) / (index_weights * constant_value)) + (np.sin(item / residual_capacities) * np.exp((item * residual_capacities) + np.log(index_weights) - constant_value))\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on the item size and residual capacities, using various mathematical functions and modifying the index weights.}\\n\\n{My new algorithm: The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the hyperbolic tangent and the natural logarithm functions are replaced with the logarithmic and exponential functions, respectively, and the indexing weights are squared and added to the bin capacities before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = bins\\n scores = ((residual_capacities + np.log(item / residual_capacities)) / index_weights) * np.exp(item * residual_capacities)\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of factors including the item size, the remaining capacity, the position index of each bin, and the logarithm of the sum of the item size and the residual capacity, all divided by the square root of the index weights plus a constant value of 10, and multiplied by the sine of the ratio between the item size and the residual capacity. The algorithm then assigns scores to each bin and returns an array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n index_weights = np.sqrt(np.arange(len(bins)))\\n scores = (item * residual_capacities) / (np.log(item + residual_capacities) + index_weights) * np.sin(item / residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is a modified version of the original algorithm. It uses a different parameter setting for the score function. The constant_value in the score function is set to 5, and the index_weights are raised to the power of 2 before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.ones(len(bins))\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the sine and exponential functions are used, and the indexing weights are squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.square(np.array(range(len(bins))) + constant_value) ** 2\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"code\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 2\\n residual_capacities = bins - item\\n index_weights = np.power(np.array(range(len(bins))) + constant_value, np.exp(constant_value))\\n scores = (residual_capacities + np.sin(item / residual_capacities)) / index_weights * (item * residual_capacities) ** np.exp(constant_value)\\n \\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights, the residual capacities are raised to the power of the item squared, and then multiplied by a constant value before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 10\\n residual_capacities = bins - item\\n scores = (np.log(item) * (residual_capacities ** (item ** 2)) + np.cos(item / residual_capacities)) * constant_value * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a modified version of the original score function, where the logarithm function is applied to the index weights and the residual capacities are raised to the power of the item squared before being used in the score calculation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n constant_value = 5\\n residual_capacities = bins - item\\n index_weights = np.log(np.array(range(len(bins))) + constant_value) ** 3\\n scores = (residual_capacities ** (item ** 3) + np.cos(item / residual_capacities)) / index_weights * np.exp(item * residual_capacities)\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\n The algorithm will calculate the score for each bin based on the remaining capacity and the size of the item, and then return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) / item\\n scores[bins == max_capacity] = -np.inf\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin by taking into account the rest capacity and sorting them in descending order, assigning the item to the bin with the maximum score and not using bins with maximum capacity, with the final goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sorted_bins = np.sort(bins)[::-1]\\n rest_capacities = sorted_bins - item\\n rest_capacities[rest_capacities == max(bins)] = -1\\n scores = rest_capacities / np.arange(1, len(sorted_bins) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the scores for each bin based on the remaining capacity and the proximity to the item size, then returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] >= item:\\n scores[i] = ((bins[i] - item) / (bins[i] + 1)) * (1 / (1 + i))\\n return scores\",\n \"objective\": 0.07989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function assigns items to bins based on the maximum score, while avoiding using bins at maximum capacity in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins.\\\"\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == np.max(bins)] = -1\\n scores = remaining_capacity / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe algorithm will calculate the scores for each bin based on the rest capacity, with higher scores for bins with more remaining capacity, and a maximum score for bins with full capacity. The goal is to minimize the number of used bins by assigning the item to the bin with the maximum score in each step.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, bins - item) / (bins.max() - item)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will assign a score to each bin based on the remaining capacity after placing the item. The score will be calculated by taking the reciprocal of the difference between the bin capacity and the item size, multiplied by a penalty factor if the bin is already at maximum capacity. Higher scores indicate better candidates for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty_factor = 1000\\n scores = np.zeros_like(bins, dtype=float)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n if remaining_capacity >= item:\\n scores[i] = 1 / (remaining_capacity - item + 1)\\n else:\\n scores[i] = 1 / (remaining_capacity - item) * penalty_factor\\n \\n return scores\",\n \"objective\": 0.15595,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm calculates the score for each bin based on the rest capacity and assigns the item to the bin with the maximum score, aiming to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n rest_capacity = np.maximum(0, max_capacity - bins) # Calculate rest capacity\\n mask = rest_capacity < item # Check if rest capacity is enough for the item\\n rest_capacity[mask] = 0 # Set rest capacity to 0 if it's not enough\\n scores = rest_capacity / (max_capacity * (1 - mask)) # Calculate scores for each bin\\n return scores\",\n \"objective\": 0.31975,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the score for each bin by taking the ratio of the rest capacity to the item size, and then subtracting 1 if the rest capacity equals the maximum capacity, in order to prioritize the bin with the largest available space but not the maximum capacity, with the main steps being to calculate the scores and return them as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == np.max(bins))\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the new algorithm as follows:\\nThe algorithm will calculate the score for each bin based on the remaining capacity after assigning the item, with a penalty for bins at maximum capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) - (bins == bins.max()) * (item + 1)\\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the remaining capacity of each bin after assigning the item, and then assigns a score to each bin based on the ratio of remaining capacity to the maximum capacity, with a penalty for bins with maximum capacity. It then returns the scores for all bins using Numpy array. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_ratio = remaining_capacity / np.max(bins)\\n remaining_ratio[bins == np.max(bins)] -= 0.5 # Apply penalty for bins with maximum capacity\\n scores = remaining_ratio\\n return scores\",\n \"objective\": 0.40739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves ranking the bins based on their remaining capacity after assigning the item, and penalizing bins with maximum capacity to discourage their use. First, calculate the remaining capacity of each bin after assigning the item, then calculate the score for each bin by considering its remaining capacity and penalizing bins with maximum capacity. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalized_capacity = np.where(remaining_capacity < np.max(remaining_capacity), remaining_capacity, np.max(remaining_capacity) * 2)\\n scores = penalized_capacity * (1 + np.log(1 + np.abs(penalized_capacity - np.max(penalized_capacity))))\\n return scores\",\n \"objective\": 0.5735,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacities of the bins after assigning the item to each bin, then computes the scores by taking the minimum between the available capacity and the item size, and finally returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.maximum(bins - item, 0)\\n scores = np.minimum(capacities, item)\\n return scores\",\n \"objective\": 0.64021,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: First, calculate the free space in each bin after adding the item, then compute the score for each bin using a novel formula that takes into account the free space and the distance from the maximum capacity, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_space = bins - item\\n max_capacity = np.max(bins)\\n distance_from_max = max_capacity - remaining_space\\n scores = remaining_space * (1 + distance_from_max)\\n return scores\",\n \"objective\": 0.77412,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will calculate the score for each bin based on the following formula: score = (bin_capacity - item_size) * (1 - bin_index/N), where N is the total number of bins. Then, the function will return the scores for each bin in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n N = len(bins)\\n scores = (bins - item) * (1 - np.arange(N)/N)\\n return scores\",\n \"objective\": 0.89174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the available capacity of each bin after adding the item, and then scores each bin based on the formula: ((maximum capacity - available capacity) / maximum capacity) * available capacity, where bins with the maximum capacity are not scored. Finally, the function returns the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n available_capacity = np.maximum(0, (bins + item) - max_capacity)\\n scores = ((max_capacity - available_capacity) / max_capacity) * available_capacity\\n scores[available_capacity == 0] = 0\\n return scores\",\n \"objective\": 1.21401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplementing the algorithm:\\n1. Create a function named score that accepts two input parameters: 'item' and 'bins'.\\n2. Inside the function, calculate the scores for each bin by first finding the difference between the maximum capacity of each bin and the size of the item.\\n3. For bins that have a rest capacity equal to the maximum capacity, assign a score of -1 to make them ineligible for item assignment.\\n4. Return the calculated scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) + (bins == bins.max()).astype(int) * -1\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm: The algorithm first calculates the scores for each bin based on the rest capacity and the current item size, then it returns the scores for the bins for assignment.\\n\\nImplement the algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0)\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus one.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.log(remaining_capacity) / np.log(min_remaining_capacity) * (1 / (np.arange(len(bins)) + 1) + 1)\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, aiming to minimize the number of used bins. The score is calculated by dividing the remaining capacity of each bin by the minimum remaining capacity of all the bins, and multiplying it by the reciprocal of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.array(bins) - item\\n min_capacity = np.min(remaining_capacity)\\n scores = remaining_capacity / min_capacity * (1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.02626,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the reciprocal of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, and the square of the bin index plus one, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (1 / (remaining_capacity / min_remaining_capacity)) * ((np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus one, and finally adding a constant factor of 0.5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity) * (1 / (np.arange(len(bins)) + 1) + 1) + 0.5\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin, the item size, and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the ratio of the remaining capacity of each bin to the item size, multiplied by the logarithm of the inverse of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity / item * np.log(1 / (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the cube root of the remaining capacity of each bin divided by the cube root of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index squared, and finally adding a constant factor of 1 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity ** (1/3)) / (min_remaining_capacity ** (1/3)) * ((1 / (np.arange(len(bins)) + 1)) ** 2) + 1\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus one.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.random.choice(bins) - item\\n scores = np.log(remaining_capacity) * (1 / (np.arange(len(bins)) + 1) + 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin, the proximity to the item size, and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on a combination of the logarithm of the remaining capacity of each bin, the size of the item, the inverse of the bin index, and a penalty factor for bins that have a remaining capacity very close to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (1 / (np.arange(len(bins)) + 1))\\n penalty_factor = np.where(np.abs(remaining_capacity - item) <= 0.01 * item, 0.9, 1)\\n scores *= penalty_factor\\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity and a bonus for bins at half capacity, and return the scores in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - (bins == half_capacity) * item / 2\\n return scores\",\n \"objective\": 0.04296,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index squared, and finally adding a constant factor of 2 to each score to promote performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity ** 0.5) / (min_remaining_capacity ** 0.5) * ((1 / (np.arange(len(bins)) + 1)) ** 2) + 2\\n return scores\",\n \"objective\": 0.04487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the square root of the remaining capacity of each bin and the inverse of the bin index plus one, raised to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = np.sqrt(remaining_capacity) * (1 / (np.arange(len(bins)) + 1)) ** item\\n return scores\",\n \"objective\": 0.05383,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin, the item size, and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin with a modified logarithm of the inverse of the bin index plus two, where the modified logarithm is calculated by multiplying the natural logarithm of the inverse of the bin index plus two with a constant factor of 0.1, and the result is then raised to the power of the rest capacity divided by the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n modified_logarithm = np.log(1 / (np.arange(len(bins)) + 2)) * 0.1\\n scores = remaining_capacity * (modified_logarithm ** (remaining_capacity / item))\\n return scores\",\n \"objective\": 0.05423,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the maximum score, considering the difference in capacity between the potential bins and the item size, and also taking into account the number of items already assigned to each bin, to further minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n valid_bins = bins[bins > item]\\n scores = (valid_bins - item) * (1 + np.log10(len(valid_bins) + 1))\\n scores[np.where(valid_bins == np.max(valid_bins))] = 0\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The algorithm involves calculating the scores for each bin based on their remaining capacity, assigning a penalty to bins that are close to their maximum capacity, and assigning a bonus to bins with a large remaining capacity, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n scores += (bins.max() - bins) / 100\\n scores += (bins - item) / 1000\\n return scores\",\n \"objective\": 0.05886,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin, the item size, and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the square root of the remaining capacity of each bin divided by the square root of the maximum remaining capacity of all the bins, multiplied by the inverse of the bin index squared, and finally adding a constant factor of 10 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_remaining_capacity = np.max(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(max_remaining_capacity)) * ((1 / (np.arange(len(bins)) + 1)) ** 2) + 10\\n return scores\",\n \"objective\": 0.05896,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm involves calculating the scores for each bin based on their remaining capacity and assigning the item to the bin with the maximum score, while ensuring not to use bins with maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: In the new algorithm, the score function assigns items to bins based on the maximum score, while also considering the difference in capacity between the potential bins and the item size, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins > item]\\n scores[:len(valid_bins)] = valid_bins - item\\n scores[np.where(bins == np.max(bins))] = 0\\n return scores\",\n \"objective\": 0.06429,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) * (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 2, raised to the power of the square root of the item size.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 2) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"{My new algorithm will calculate the scores for each bin by taking the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, then multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a constant factor of 5000.}\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 5000\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) * (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all bins, multiplied by the square root of the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by the exponential function of the item size plus 2, raised to the power of the logarithm of the item size plus the maximum remaining capacity of all bins.\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n max_remaining_capacity = np.max(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 2) ** np.log(item + max_remaining_capacity)))\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n max_remaining_capacity = np.max(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 2) ** np.log(item + max_remaining_capacity)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.log(item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin by taking the square root of the remaining capacity of each bin divided by the minimum remaining capacity, then multiplying it by the item size raised to the power of the bin index divided by three times the item size, and finally multiplying it by a constant factor of 10000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (3 * item))) * 10000\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by a factor that is the product of the item size and the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item * (np.arange(len(bins)) + 1)) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity) + 5\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities, and then multiplied by a constant factor of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities)) * 10\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by dividing the logarithm of the remaining capacity of each bin by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the cubic root of the item size raised to the power of the bin index divided by the cubic root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 3, raised to the power of the cubic root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item ** (1/3)) ** (np.arange(len(bins)) / (sum_bin_capacities ** (1/3)))) * ((np.exp(item + 3) ** (item ** (1/3))) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the bin index times the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n bin_index = np.arange(len(bins))\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(bin_index) * (item ** np.sqrt(bin_index))) * (np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm will calculate the scores for each bin based on the cube root of the remaining capacity of each bin divided by the cube root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by the double of the item size, and finally multiplied by a factor of 1000, in order to prioritize bins with lower capacity and lower bin index for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.cbrt(remaining_capacity) / np.cbrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 1000\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) * (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 2, raised to the power of the square root of the item size.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 2) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) * (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the scores for each bin by taking the logarithm of the remaining capacity of each bin divided by the minimum remaining capacity, then multiplying it by the cube root of the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a constant factor of 100.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 100\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.log(item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 1000\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item based on the rest capacity, the item size and the bin index of each bin. The score will be calculated as the product of the item size raised to the power of the bin index divided by twice the item size, multiplied by the square root of the remaining capacity divided by the square root of the minimum remaining capacity of all the bins, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin and the minimum remaining capacity among all the bins, as well as the item size and the bin index.}\\n\\n{My new algorithm assigns scores to each bin by taking the product of the cube root of the remaining capacity of each bin divided by the cube root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by four times the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.cbrt(remaining_capacity) / np.cbrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (4 * item))) * 1000\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the bin index times the item size raised to the power of the square root of the bin index, divided by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n bin_index = np.arange(len(bins))\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(bin_index) * (item ** np.sqrt(bin_index))) / (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the bin index times the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n bin_index = np.arange(len(bins))\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(bin_index) * (item ** np.sqrt(bin_index))) * (np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) / (np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 2, raised to the power of the square root of the item size.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 2) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the scores for each bin by taking the logarithm of the remaining capacity of each bin divided by the minimum remaining capacity, then multiplying it by the cube root of the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a constant factor of 100.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 100\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.log(item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the difference between the logarithm of the remaining capacity of each bin and the logarithm of the minimum remaining capacity among all the bins, divided by the logarithm of the item size plus one, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (((np.log(remaining_capacity) - np.log(min_remaining_capacity)) / (np.log(item) + 1)) * (item ** (np.arange(len(bins)) / (2 * item)))) * 1000\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 1000\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item based on the rest capacity, the item size and the bin index of each bin. The score will be calculated as the product of the item size raised to the power of the bin index divided by twice the item size, multiplied by the square root of the remaining capacity divided by the square root of the minimum remaining capacity of all the bins, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin and the minimum remaining capacity among all the bins, as well as the item size and the bin index.}\\n\\n{My new algorithm assigns scores to each bin by taking the product of the cube root of the remaining capacity of each bin divided by the cube root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by four times the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.cbrt(remaining_capacity) / np.cbrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (4 * item))) * 1000\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) / (np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.log(item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the difference between the logarithm of the remaining capacity of each bin and the logarithm of the minimum remaining capacity among all the bins, divided by the logarithm of the item size plus one, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (((np.log(remaining_capacity) - np.log(min_remaining_capacity)) / (np.log(item) + 1)) * (item ** (np.arange(len(bins)) / (2 * item)))) * 1000\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 1000\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item based on the rest capacity, the item size and the bin index of each bin. The score will be calculated as the product of the item size raised to the power of the bin index divided by twice the item size, multiplied by the square root of the remaining capacity divided by the square root of the minimum remaining capacity of all the bins, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin and the minimum remaining capacity among all the bins, as well as the item size and the bin index.}\\n\\n{My new algorithm assigns scores to each bin by taking the product of the cube root of the remaining capacity of each bin divided by the cube root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by four times the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.cbrt(remaining_capacity) / np.cbrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (4 * item))) * 1000\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) / (np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.log(item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the difference between the logarithm of the remaining capacity of each bin and the logarithm of the minimum remaining capacity among all the bins, divided by the logarithm of the item size plus one, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (((np.log(remaining_capacity) - np.log(min_remaining_capacity)) / (np.log(item) + 1)) * (item ** (np.arange(len(bins)) / (2 * item)))) * 1000\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by multiplying the item size raised to the power of the bin index divided by three times the item size, by the square root of the remaining capacity divided by the square root of the minimum remaining capacity, and finally by a factor of 100 to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (3 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / np.min(remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item based on the rest capacity, the item size and the bin index of each bin. The score will be calculated as the product of the item size raised to the power of the bin index divided by twice the item size, multiplied by the square root of the remaining capacity divided by the square root of the minimum remaining capacity of all the bins, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin and the minimum remaining capacity among all the bins, as well as the item size and the bin index.}\\n\\n{My new algorithm assigns scores to each bin by taking the product of the cube root of the remaining capacity of each bin divided by the cube root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by four times the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.cbrt(remaining_capacity) / np.cbrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (4 * item))) * 1000\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) / (np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on their remaining capacity and the position of the item, aiming to minimize the number of used bins. The score will be calculated as the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the difference between the logarithm of the remaining capacity of each bin and the logarithm of the minimum remaining capacity among all the bins, divided by the logarithm of the item size plus one, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (((np.log(remaining_capacity) - np.log(min_remaining_capacity)) / (np.log(item) + 1)) * (item ** (np.arange(len(bins)) / (2 * item)))) * 1000\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by multiplying the item size raised to the power of the bin index divided by three times the item size, by the square root of the remaining capacity divided by the square root of the minimum remaining capacity, and finally by a factor of 100 to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (3 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / np.min(remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item based on the rest capacity, the item size and the bin index of each bin. The score will be calculated as the product of the item size raised to the power of the bin index divided by twice the item size, multiplied by the square root of the remaining capacity divided by the square root of the minimum remaining capacity of all the bins, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin and the minimum remaining capacity among all the bins, as well as the item size and the bin index.}\\n\\n{My new algorithm assigns scores to each bin by taking the product of the cube root of the remaining capacity of each bin divided by the cube root of the minimum remaining capacity among all the bins, and multiplying it by the item size raised to the power of the bin index divided by four times the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.cbrt(remaining_capacity) / np.cbrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (4 * item))) * 1000\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on its remaining capacity and the size of the item being assigned. The score is calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n bin_indices = np.arange(len(bins))\\n scores = (item * np.sqrt(bin_indices + 1)) ** (np.sqrt(bin_indices + 1)) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) / (np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on their remaining capacity and the position of the item, aiming to minimize the number of used bins. The score will be calculated as the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin by taking the product of the difference between the logarithm of the remaining capacity of each bin and the logarithm of the minimum remaining capacity among all the bins, divided by the logarithm of the item size plus one, and multiplying it by the item size raised to the power of the bin index divided by twice the item size, and finally multiplying it by a factor of 1000.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (((np.log(remaining_capacity) - np.log(min_remaining_capacity)) / (np.log(item) + 1)) * (item ** (np.arange(len(bins)) / (2 * item)))) * 1000\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by multiplying the item size raised to the power of the bin index divided by three times the item size, by the square root of the remaining capacity divided by the square root of the minimum remaining capacity, and finally by a factor of 100 to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (3 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / np.min(remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item based on the rest capacity, the item size and the bin index of each bin. The score will be calculated as the product of the item size raised to the power of the bin index divided by twice the item size, multiplied by the square root of the remaining capacity divided by the square root of the minimum remaining capacity of all the bins, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on its remaining capacity and the size of the item being assigned. The score is calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n bin_indices = np.arange(len(bins))\\n scores = (item * np.sqrt(bin_indices + 1)) ** (np.sqrt(bin_indices + 1)) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) / (np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the original algorithm by taking the natural logarithm of the remaining capacity of each bin divided by the natural logarithm of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by the square root of the bin index plus one, and finally multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item ** (np.arange(len(bins)) / np.sqrt(np.arange(len(bins)) + 1))) * (item ** np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on their remaining capacity and the position of the item, aiming to minimize the number of used bins. The score will be calculated as the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity of the bin divided by the minimum remaining capacity among all the bins, multiplied by the item size to the power of the bin index divided by twice the item size, and finally multiplied by the square root of the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (bins - item) / min_remaining_capacity * (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(item) / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by multiplying the item size raised to the power of the bin index divided by three times the item size, by the square root of the remaining capacity divided by the square root of the minimum remaining capacity, and finally by a factor of 100 to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (3 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / np.min(remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by the square root of the bin index plus one, and finally multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins - item) / np.sqrt(np.min(bins - item))) * (item ** (np.arange(len(bins)) / np.sqrt(np.arange(len(bins)) + 1))) * (item ** np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on its remaining capacity and the size of the item being assigned. The score is calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n bin_indices = np.arange(len(bins))\\n scores = (item * np.sqrt(bin_indices + 1)) ** (np.sqrt(bin_indices + 1)) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index, multiplied by a factor of 1000 to prioritize lower capacity bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n bin_indices = np.arange(len(bins))\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** np.sqrt(bin_indices)) * 1000\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the original algorithm by taking the natural logarithm of the remaining capacity of each bin divided by the natural logarithm of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by the square root of the bin index plus one, and finally multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item ** (np.arange(len(bins)) / np.sqrt(np.arange(len(bins)) + 1))) * (item ** np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on their remaining capacity and the position of the item, aiming to minimize the number of used bins. The score will be calculated as the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity of the bin divided by the minimum remaining capacity among all the bins, multiplied by the item size to the power of the bin index divided by twice the item size, and finally multiplied by the square root of the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (bins - item) / min_remaining_capacity * (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(item) / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by multiplying the item size raised to the power of the bin index divided by three times the item size, by the square root of the remaining capacity divided by the square root of the minimum remaining capacity, and finally by a factor of 100 to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (item ** (np.arange(len(bins)) / (3 * item))) * (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * 100\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / np.min(remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity / min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by the square root of the bin index plus one, and finally multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins - item) / np.sqrt(np.min(bins - item))) * (item ** (np.arange(len(bins)) / np.sqrt(np.arange(len(bins)) + 1))) * (item ** np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on its remaining capacity and the size of the item being assigned. The score is calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n bin_indices = np.arange(len(bins))\\n scores = (item * np.sqrt(bin_indices + 1)) ** (np.sqrt(bin_indices + 1)) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index, multiplied by a factor of 1000 to prioritize lower capacity bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n bin_indices = np.arange(len(bins))\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** np.sqrt(bin_indices)) * 1000\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the original algorithm by taking the natural logarithm of the remaining capacity of each bin divided by the natural logarithm of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by the square root of the bin index plus one, and finally multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item ** (np.arange(len(bins)) / np.sqrt(np.arange(len(bins)) + 1))) * (item ** np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on their remaining capacity and the position of the item, aiming to minimize the number of used bins. The score will be calculated as the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity of the bin divided by the minimum remaining capacity among all the bins, multiplied by the item size to the power of the bin index divided by twice the item size, and finally multiplied by the square root of the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (bins - item) / min_remaining_capacity * (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(item) / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 1000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity / min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 1000\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / np.min(remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity / min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the square root of the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item) * (np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the factor of the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** item) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by the square root of the bin index plus one, and finally raised to the power of the item size plus one, while also adding a constant factor of 2 to each score to promote performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** (item + 1)) + 2\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.log(remaining_capacity) / np.log(np.min(remaining_capacity))) * (np.sqrt(np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score will be calculated based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the inverse of the remaining capacity of each bin divided by the maximum remaining capacity of all the bins, and the exponential function of the bin index plus one, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_remaining_capacity = np.max(remaining_capacity)\\n scores = (1 / remaining_capacity) / (1 / max_remaining_capacity) * (np.exp(np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus one.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.log(remaining_capacity) / np.log(min_remaining_capacity) * (1 / (np.arange(len(bins)) + 1) + 1)\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bins, aiming to minimize the number of used bins. The score is calculated by dividing the remaining capacity of each bin by the minimum remaining capacity of all the bins, and multiplying it by the reciprocal of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.array(bins) - item\\n min_capacity = np.min(remaining_capacity)\\n scores = remaining_capacity / min_capacity * (1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.02626,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the reciprocal of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, and the square of the bin index plus one, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (1 / (remaining_capacity / min_remaining_capacity)) * ((np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.0336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus two, and finally adding a constant factor of 1 to each score to promote performance.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.log(remaining_capacity) / np.log(min_remaining_capacity) * (1 / (np.arange(len(bins)) + 2)) + 1\\n return scores\",\n \"objective\": 0.03562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity) * (1 / (np.arange(len(bins)) + 1) + 1)\\n return scores\",\n \"objective\": 0.03592,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, a bonus for bins at half capacity, and an additional bonus for bins where the remaining capacity is close to the size of the item.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n diff_capacity = abs(bins - item)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item - (bins == half_capacity) * item / 2 + (diff_capacity < item/4) * (item / 4)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin, the item size, and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the ratio of the remaining capacity of each bin to the item size, multiplied by the logarithm of the inverse of the bin index plus two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = remaining_capacity / item * np.log(1 / (np.arange(len(bins)) + 2))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and an exponential bonus for bins at half capacity, multiplied by the square root of the bin index plus one, and finally adding a constant factor of 3 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) - (bins == max_capacity) * item + (bins == half_capacity) * (item ** 2) * np.sqrt(np.arange(len(bins)) + 1) + 3\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the inverse of the remaining capacity of each bin divided by the sum of the remaining capacities of all the bins, multiplied by the inverse of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n sum_remaining_capacity = np.sum(remaining_capacity)\\n scores = (1 / (remaining_capacity + 1e-10)) / (sum_remaining_capacity + 1e-10) * (1 / (np.arange(len(bins)) + 1) + 1)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins at maximum capacity, and return the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = max_capacity - bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the natural logarithm of the remaining capacity of each bin divided by the natural logarithm of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus one squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.log(remaining_capacity) / np.log(min_remaining_capacity) * (1 / (np.arange(len(bins)) + 1) ** 2)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin, the item size, and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the inverse of the bin index raised to the power of the square root of the item size, multiplied by the item size divided by the remaining capacity of each bin, and finally adding a constant factor of 1 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (1 / (np.arange(len(bins)) + 1) ** np.sqrt(item)) * (item / remaining_capacity) + 1\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(np.min(bins - item))) * (np.sqrt(item) * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.sqrt(item) ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by the square root of the bin index plus one, and finally multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins - item) / np.sqrt(np.min(bins - item))) * (item ** (np.arange(len(bins)) / np.sqrt(np.arange(len(bins)) + 1))) * (item ** np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm modifies the scoring function by taking the square root of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the cube root of the item size and the bin index plus one, raised to the power of the cube root of the bin index plus one, and finally multiplied by the item size raised to the power of the minimum remaining capacity, plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(np.log1p(bins - item) / np.log1p(np.min(bins - item))) * ((item * np.cbrt(np.arange(len(bins)) + 1)) ** np.cbrt(np.arange(len(bins)) + 1))) * ((item ** np.min(bins - item)) + 1)\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index, multiplied by a factor of 1000 to prioritize lower capacity bins for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n bin_indices = np.arange(len(bins))\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** np.sqrt(bin_indices)) * 1000\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the square root of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)))) * (np.exp(item + 1) ** np.log(item))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log1p(bins - item) / np.log1p(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the remaining capacity of each bin to the minimum remaining capacity among all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)))) * (item ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the original algorithm by taking the natural logarithm of the remaining capacity of each bin divided by the natural logarithm of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by the square root of the bin index plus one, and finally multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item ** (np.arange(len(bins)) / np.sqrt(np.arange(len(bins)) + 1))) * (item ** np.sqrt(np.arange(len(bins))))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item)))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the natural logarithm of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm modifies the scoring function by taking the square of the natural logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the cube root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item) / np.log(np.min(bins - item))) * (item * np.cbrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** np.min(bins - item))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on their remaining capacity and the position of the item, aiming to minimize the number of used bins. The score will be calculated as the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity of the bin divided by the minimum remaining capacity among all the bins, multiplied by the item size to the power of the bin index divided by twice the item size, and finally multiplied by the square root of the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (bins - item) / min_remaining_capacity * (item ** (np.arange(len(bins)) / (2 * item))) * (np.sqrt(item) / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 1000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity / min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 1000\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 10 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (remaining_capacity / np.min(remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 100 to prioritize the bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity) * (item ** (np.arange(len(bins)) / (2 * item))) * 100\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity among all the bins and the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a constant factor of 10000, in order to prioritize bins with lower capacity and lower bin index for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity / min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * 10000\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the sum of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor of 1000 raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * (1000 ** np.log(item))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log(bins - item) / np.log(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 1) ** np.sqrt(item)) + 3)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin plus one, divided by the logarithm of the minimum remaining capacity of all the bins plus one, multiplied by the square root of the bin index plus one, raised to the power of the item size, and finally multiplied by the bin index raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity + 1) / np.log(min_remaining_capacity + 1)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size, the square root of the bin index plus one raised to the power of the item size, and finally multiplied by the bin index divided by the square root of the item size raised to the power of the square root of the item size, adding a constant factor of 5 to each score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item * (np.sqrt(np.arange(len(bins)) + 1) ** item)) * ((np.arange(len(bins)) / np.sqrt(item)) ** np.sqrt(item)) + 5\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the square root of the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item) * (np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the factor of the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** item) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by the square root of the bin index plus one, and finally raised to the power of the item size plus one, while also adding a constant factor of 2 to each score to promote performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** (item + 1)) + 2\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.log(remaining_capacity) / np.log(np.min(remaining_capacity))) * (np.sqrt(np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score will be calculated based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of 1 plus the remaining capacity of each bin divided by the logarithm of 1 plus the minimum remaining capacity, multiplied by the square root of the bin index plus one, and finally raised to the power of the item size plus one, while also adding a constant factor of 3 to each score to promote performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(1 + remaining_capacity) / np.log(1 + min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** (item + 1)) + 3\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the inverse of the remaining capacity of each bin divided by the maximum remaining capacity of all the bins, and the exponential function of the bin index plus one, raised to the power of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n max_remaining_capacity = np.max(remaining_capacity)\\n scores = (1 / remaining_capacity) / (1 / max_remaining_capacity) * (np.exp(np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the bin index divided by the square root of the item size, raised to the power of the square root of the item size, and the constant factor of 3 will also be added to each score.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) / np.sqrt(item)) ** np.sqrt(item))) + 3\\n return scores\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the bin index divided by the square root of the item size, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) / np.sqrt(item)) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.01962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplied by the square root of the bin index divided by the item size, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item) * (np.sqrt(np.arange(len(bins))) / item) ** np.sqrt(item)\\n return scores\",\n \"objective\": 0.01992,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the inverse of the bin index plus one.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.log(remaining_capacity) / np.log(min_remaining_capacity) * (1 / (np.arange(len(bins)) + 1) + 1)\\n return scores\",\n \"objective\": 0.02042,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the inverse of the remaining capacity of each bin divided by the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the square root of the item size and the bin's index plus one, raised to the power of the product of the square root of the item size and the bin's index, and finally multiplied by the item size raised to the power of the minimum remaining capacity squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n reciprocal_bins = 1 / (bins - item)\\n scores = reciprocal_bins * (np.arange(len(bins)) + 1) ** (np.sqrt(item) * (np.arange(len(bins)) + 1)) * (item ** (min_remaining_capacity ** 2))\\n return scores\",\n \"objective\": 0.02133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the multiplication of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins and the exponential function of the item index minus the bin index plus one, raised to the power of the square root of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.sqrt(item) * (np.arange(len(bins)) - item + 1)))\\n return scores\",\n \"objective\": 0.02214,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square of the bin index plus one, raised to the power of the item size, multiplied by the inverse of the bin index plus one.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.arange(len(bins)) + 1) ** item) * (1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.02304,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log(bins - item) / np.log(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 1) ** np.sqrt(item)) + 3)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the sum of all bin capacities divided by the item size, raised to the power of the square root of the bin index times the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (((np.sqrt(sum_bin_capacities) / item) ** np.sqrt(np.arange(len(bins)))) * item)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by taking the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the square root of the item size raised to the power of the square root of the bin index divided by the square root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 1, raised to the power of the square root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)))) / (np.sqrt(sum_bin_capacities))) * ((np.exp(item + 1) ** np.sqrt(item)) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin plus one, divided by the logarithm of the minimum remaining capacity of all the bins plus one, multiplied by the square root of the bin index plus one, raised to the power of the item size, and finally multiplied by the bin index raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity + 1) / np.log(min_remaining_capacity + 1)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.array(bins) - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity + 1) / np.log(min_remaining_capacity + 1)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the sum of the logarithm of the remaining capacity of the bin divided by the logarithm of the minimum remaining capacity of all the bins and the square root of the item size, multiplied by the exponential function of the item index plus one raised to the power of the item size, and by the bin index raised to the power of the square root of the item size, finally dividing it by the logarithm of the sum of the remaining capacity of all the bins plus one, taken to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_remaining_capacity = np.sum(remaining_capacity)\\n scores = ((np.log(remaining_capacity) / np.log(min_remaining_capacity)) + np.sqrt(item)) * ((np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) + 1) ** np.sqrt(item))) / (np.log(sum_remaining_capacity + 1) ** item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size, the square root of the bin index plus one raised to the power of the item size, and finally multiplied by the bin index divided by the square root of the item size raised to the power of the square root of the item size, adding a constant factor of 5 to each score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item * (np.sqrt(np.arange(len(bins)) + 1) ** item)) * ((np.arange(len(bins)) / np.sqrt(item)) ** np.sqrt(item)) + 5\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the square root of the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.log(remaining_capacity) / np.log(np.min(remaining_capacity))) * (np.exp(np.arange(len(bins)) + 1) ** item) * (np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the factor of the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** item) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by the square root of the bin index plus one, and finally raised to the power of the item size plus one, while also adding a constant factor of 2 to each score to promote performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** (item + 1)) + 2\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.log(remaining_capacity) / np.log(np.min(remaining_capacity))) * (np.sqrt(np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by the square root of the bin index plus one, and finally raised to the power of the item size plus two, while also adding a constant factor of 4 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** (item + 2)) + 4\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score will be calculated based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.0168,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of 1 plus the remaining capacity of each bin divided by the logarithm of 1 plus the minimum remaining capacity, multiplied by the square root of the bin index plus one, and finally raised to the power of the item size plus one, while also adding a constant factor of 3 to each score to promote performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(1 + remaining_capacity) / np.log(1 + min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** (item + 1)) + 3\\n return scores\",\n \"objective\": 0.0169,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score will be calculated based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.arange(len(bins)) + 1) ** item)\\n return scores\",\n \"objective\": 0.017,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the inverse of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by a factor that is the product of the square root of the item size and the bin's index, raised to the power of the product of the square root of the item size and the bin's index, and finally multiplied by the item size raised to the power of the minimum remaining capacity squared, while also adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(bins - item)\\n scores = (1 / (np.log(remaining_capacity) / np.log(min_remaining_capacity))) * (np.sqrt(item) * (np.arange(len(bins)) + 1) ** (np.sqrt(item) * (np.arange(len(bins)) + 1))) * (item ** (min_remaining_capacity ** 2)) + 5\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log(bins - item) / np.log(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 1) ** np.sqrt(item)) + 3)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin, the minimum remaining capacity of all the bins, and the item size.}\\n\\n{My new algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size and the exponential function of the item index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) * (item ** min_remaining_capacity) * (item ** np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by taking the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the square root of the item size raised to the power of the square root of the bin index divided by the square root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 1, raised to the power of the square root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)))) / (np.sqrt(sum_bin_capacities))) * ((np.exp(item + 1) ** np.sqrt(item)) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by dividing the logarithm of the remaining capacity of each bin by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the cubic root of the item size raised to the power of the bin index divided by the cubic root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 3, raised to the power of the cubic root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item ** (1/3)) ** (np.arange(len(bins)) / (sum_bin_capacities ** (1/3)))) * ((np.exp(item + 3) ** (item ** (1/3))) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size raised to the power of the bin index times the item size, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)) + 1)) * np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin by taking the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all bins, and multiplying it by the exponential of the square root of the bin index divided by the square root of the item size, raised to the power of the square root of the item size plus one, while also adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.sqrt(np.arange(len(bins))) / np.sqrt(item)) ** (np.sqrt(item) + 1)) + 5\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.sqrt(item) / np.sqrt(np.arange(len(bins)) + 1)) * np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin plus one, divided by the logarithm of the minimum remaining capacity of all the bins plus one, multiplied by the square root of the bin index plus one, raised to the power of the item size, and finally multiplied by the bin index raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity + 1) / np.log(min_remaining_capacity + 1)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.array(bins) - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity + 1) / np.log(min_remaining_capacity + 1)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the sum of the logarithm of the remaining capacity of the bin divided by the logarithm of the minimum remaining capacity of all the bins and the square root of the item size, multiplied by the exponential function of the item index plus one raised to the power of the item size, and by the bin index raised to the power of the square root of the item size, finally dividing it by the logarithm of the sum of the remaining capacity of all the bins plus one, taken to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_remaining_capacity = np.sum(remaining_capacity)\\n scores = ((np.log(remaining_capacity) / np.log(min_remaining_capacity)) + np.sqrt(item)) * ((np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) + 1) ** np.sqrt(item))) / (np.log(sum_remaining_capacity + 1) ** item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size, the square root of the bin index plus one raised to the power of the item size, and finally multiplied by the bin index divided by the square root of the item size raised to the power of the square root of the item size, adding a constant factor of 5 to each score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item * (np.sqrt(np.arange(len(bins)) + 1) ** item)) * ((np.arange(len(bins)) / np.sqrt(item)) ** np.sqrt(item)) + 5\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the exponential function of the item index plus one, raised to the power of the item size, and finally multiplying it by the square root of the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n scores = (np.log(remaining_capacity) / np.log(np.min(remaining_capacity))) * (np.exp(np.arange(len(bins)) + 1) ** item) * (np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by the square root of the bin index plus one, and finally raised to the power of the item size plus three, while also adding a constant factor of 3 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** (item + 3)) + 3\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the exponential function of the item size plus 2 raised to the power of the bin index plus 1, and finally multiplied by the square root of the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.exp(item + 2) ** (np.arange(len(bins)) + 1)) * (np.sqrt(item) ** min_remaining_capacity))\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the factor of the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(np.arange(len(bins)) + 1) ** item) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.0161,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log(bins - item) / np.log(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 1) ** np.sqrt(item)) + 3)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin, the minimum remaining capacity of all the bins, and the item size.}\\n\\n{My new algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size and the exponential function of the item index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) * (item ** min_remaining_capacity) * (item ** np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by a factor that is the product of the item size and the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item * (np.arange(len(bins)) + 1)) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity) + 5\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by taking the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the square root of the item size raised to the power of the square root of the bin index divided by the square root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 1, raised to the power of the square root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)))) / (np.sqrt(sum_bin_capacities))) * ((np.exp(item + 1) ** np.sqrt(item)) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by dividing the logarithm of the remaining capacity of each bin by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the cubic root of the item size raised to the power of the bin index divided by the cubic root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 3, raised to the power of the cubic root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item ** (1/3)) ** (np.arange(len(bins)) / (sum_bin_capacities ** (1/3)))) * ((np.exp(item + 3) ** (item ** (1/3))) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size raised to the power of the bin index times the item size, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)) + 1)) * np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin by taking the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all bins, and multiplying it by the exponential of the square root of the bin index divided by the square root of the item size, raised to the power of the square root of the item size plus one, while also adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.sqrt(np.arange(len(bins))) / np.sqrt(item)) ** (np.sqrt(item) + 1)) + 5\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (remaining_capacity / min_remaining_capacity) * ((np.sqrt(item) / np.sqrt(np.arange(len(bins)) + 1)) * np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size and the exponential function of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity divided by the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) * np.exp(np.sqrt(np.arange(len(bins)) + 1)) * (item ** (min_remaining_capacity / np.sqrt(np.arange(len(bins)) + 1))))\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will calculate the scores for each bin by taking the exponentiation of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the square root of the item size raised to the power of the square root of the bin index divided by the square root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the square root of the item size plus 1, raised to the power of the item size divided by the sum of all bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.exp(np.log(remaining_capacity) / np.log(min_remaining_capacity))) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)))) / (np.sqrt(sum_bin_capacities))) * ((np.exp(np.sqrt(item + 1)) ** (item / sum_bin_capacities)))\\n return scores\",\n \"objective\": 0.01268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin plus one, divided by the logarithm of the minimum remaining capacity of all the bins plus one, multiplied by the square root of the bin index plus one, raised to the power of the item size, and finally multiplied by the bin index raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity + 1) / np.log(min_remaining_capacity + 1)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.01399,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = np.array(bins) - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity + 1) / np.log(min_remaining_capacity + 1)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the combination of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, the square root of the bin index plus one, raised to the power of the item size, and finally multiplying it by the bin index raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(np.arange(len(bins)) + 1)) ** item) * ((np.arange(len(bins)) + 1) ** (np.sqrt(item)))\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the score for each bin based on the sum of the logarithm of the remaining capacity of the bin divided by the logarithm of the minimum remaining capacity of all the bins and the square root of the item size, multiplied by the exponential function of the item index plus one raised to the power of the item size, and by the bin index raised to the power of the square root of the item size, finally dividing it by the logarithm of the sum of the remaining capacity of all the bins plus one, taken to the power of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_remaining_capacity = np.sum(remaining_capacity)\\n scores = ((np.log(remaining_capacity) / np.log(min_remaining_capacity)) + np.sqrt(item)) * ((np.exp(np.arange(len(bins)) + 1) ** item) * ((np.arange(len(bins)) + 1) ** np.sqrt(item))) / (np.log(sum_remaining_capacity + 1) ** item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size, the square root of the bin index plus one raised to the power of the item size, and finally multiplied by the bin index divided by the square root of the item size raised to the power of the square root of the item size, adding a constant factor of 5 to each score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item * (np.sqrt(np.arange(len(bins)) + 1) ** item)) * ((np.arange(len(bins)) / np.sqrt(item)) ** np.sqrt(item)) + 5\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 2, raised to the power of the square root of the item size.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 2) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate the scores for each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the inverse of the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (1 / (item ** (np.arange(len(bins)) / (2 * item)))) * ((np.exp(item + 1) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log(bins - item) / np.log(min_remaining_capacity)) * ((np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 1) ** np.sqrt(item)) + 3)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin, the minimum remaining capacity of all the bins, and the item size.}\\n\\n{My new algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size and the exponential function of the item index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) * (item ** min_remaining_capacity) * (item ** np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by a factor that is the product of the item size and the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item * (np.arange(len(bins)) + 1)) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity) + 5\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by taking the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the square root of the item size raised to the power of the square root of the bin index divided by the square root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 1, raised to the power of the square root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)))) / (np.sqrt(sum_bin_capacities))) * ((np.exp(item + 1) ** np.sqrt(item)) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by dividing the logarithm of the remaining capacity of each bin by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the cubic root of the item size raised to the power of the bin index divided by the cubic root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 3, raised to the power of the cubic root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item ** (1/3)) ** (np.arange(len(bins)) / (sum_bin_capacities ** (1/3)))) * ((np.exp(item + 3) ** (item ** (1/3))) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size raised to the power of the bin index times the item size, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)) + 1)) * np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the exponential function raised to the power of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by the minimum remaining capacity divided by the square root of the bin index, adding a constant factor of 15 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.exp(np.log(bins - item) / np.log(min_remaining_capacity))) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * (min_remaining_capacity / np.sqrt(np.arange(len(bins)) + 1)) + 15\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item in a way that minimizes the number of used bins by taking the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplying it by a factor that is the product of the square root of the item size and the bin index plus one, raised to the power of the square root of the bin index, and finally multiplying it by the sum of all bin capacities divided by the item size raised to the power of the minimum remaining capacity and adding a constant factor of 10 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) * (np.arange(len(bins)) + 1)) ** np.sqrt(np.arange(len(bins)) + 1)) * (sum_bin_capacities / (item ** min_remaining_capacity)) + 10\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin by taking the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all bins, and multiplying it by the exponential of the square root of the bin index divided by the square root of the item size, raised to the power of the square root of the item size plus one, while also adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.exp(np.sqrt(np.arange(len(bins))) / np.sqrt(item)) ** (np.sqrt(item) + 1)) + 5\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the logarithm of the remaining capacity as a ratio of the minimum remaining capacity, multiplied by the logarithm of the item size raised to the power of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = np.log(remaining_capacity / min_remaining_capacity) * np.log(item) ** np.sqrt(np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate the scores for each bin based on the product of the natural logarithm of the remaining capacity of each bin divided by the natural logarithm of the minimum remaining capacity of all the bins, multiplied by the cube root of the item size and the exponential function of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the cube root of the minimum remaining capacity divided by the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.cbrt(item) * np.exp(np.sqrt(np.arange(len(bins)) + 1)) * (item ** (np.cbrt(min_remaining_capacity) / np.sqrt(np.arange(len(bins)) + 1))))\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size and the exponential function of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity divided by the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) * np.exp(np.sqrt(np.arange(len(bins)) + 1)) * (item ** (min_remaining_capacity / np.sqrt(np.arange(len(bins)) + 1))))\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) * (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 2, raised to the power of the square root of the item size.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 2) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm: The score function will calculate the scores for each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the inverse of the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (1 / (item ** (np.arange(len(bins)) / (2 * item)))) * ((np.exp(item + 1) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log(bins - item) / np.log(min_remaining_capacity)) * ((np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.log(item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin, the minimum remaining capacity of all the bins, and the item size.}\\n\\n{My new algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size and the exponential function of the item index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) * (item ** min_remaining_capacity) * (item ** np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by a factor that is the product of the item size and the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item * (np.arange(len(bins)) + 1)) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity) + 5\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 3, raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 3) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities)) * 100\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities, and then multiplied by a constant factor of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities)) * 10\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by dividing the logarithm of the remaining capacity of each bin by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the cubic root of the item size raised to the power of the bin index divided by the cubic root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 3, raised to the power of the cubic root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item ** (1/3)) ** (np.arange(len(bins)) / (sum_bin_capacities ** (1/3)))) * ((np.exp(item + 3) ** (item ** (1/3))) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the bin index times the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n bin_index = np.arange(len(bins))\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(bin_index) * (item ** np.sqrt(bin_index))) * (np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size raised to the power of the bin index times the item size, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((np.sqrt(item) ** np.sqrt(np.arange(len(bins)) + 1)) * np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the product of the exponential function raised to the power of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by the minimum remaining capacity divided by the square root of the bin index, adding a constant factor of 15 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.exp(np.log(bins - item) / np.log(min_remaining_capacity))) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * (min_remaining_capacity / np.sqrt(np.arange(len(bins)) + 1)) + 15\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_SelectionStrategy/WSRun3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm modifies the scoring function by taking the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)))) ** (np.sqrt(np.arange(len(bins)))) * ((np.log1p(bins) - np.log1p(item)) / np.log1p(min_remaining_capacity)) * np.power(item, min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) * (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the square root of the remaining capacity of the bin divided by the square root of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index plus one, and finally multiplied by the item size divided by the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.sqrt(bins - item) / np.sqrt(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 1))) * (item / np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the score function will calculate the scores for each bin to assign the item based on the rest capacity of each bin and aiming to minimize the number of used bins. The score will be calculated as the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, multiplied by the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1)) * (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item ** min_remaining_capacity)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 2, raised to the power of the square root of the item size.\\n\\nImplementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * ((np.exp(item + 2) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities, and then multiplied by a constant factor of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities)) * 10\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the product of the square of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the square root of the bin index plus two, and finally multiplied by the exponential function of the item size raised to the power of the square root of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) ** 2 / np.log1p(min_remaining_capacity)) * (item ** (np.sqrt(np.arange(len(bins)) + 2))) * (np.exp(item) ** np.sqrt(min_remaining_capacity))\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the product of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all bins, multiplied by the square root of the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by the exponential function of the item size plus 2, raised to the power of the logarithm of the item size plus the maximum remaining capacity of all bins.\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n max_remaining_capacity = np.max(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 2) ** np.log(item + max_remaining_capacity)))\\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n max_remaining_capacity = np.max(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 2) ** np.log(item + max_remaining_capacity)))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the logarithm of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.log(item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the remaining capacity of the bin, the minimum remaining capacity of all the bins, and the item size.}\\n\\n{My new algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the item size and the exponential function of the item index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and the item size raised to the power of the square root of the bin index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(item) * (item ** min_remaining_capacity) * (item ** np.sqrt(np.arange(len(bins)) + 1)))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the remaining capacity of each bin and aiming to minimize the number of used bins. The score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity, multiplied by a factor that is the product of the item size and the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity and adding a constant factor of 5 to each score to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item * (np.arange(len(bins)) + 1)) ** np.sqrt(np.arange(len(bins)) + 1)) * (item ** min_remaining_capacity) + 5\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin to assign the item, considering the rest capacity of each bin and aiming to minimize the number of used bins. In this new algorithm, the score will be calculated based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by a factor that is the product of the item size and the square root of the bin index plus one, raised to the power of the square root of the bin index, and finally multiplied by the item size raised to the power of the minimum remaining capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.log1p(bins - item) / np.log1p(min_remaining_capacity)) * (item * np.sqrt(np.arange(len(bins)) + 1) ** np.sqrt(np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 3, raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities, and then multiplied by a constant factor of 100.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 3) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities)) * 100\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on the square root of the remaining capacity of each bin divided by the square root of the minimum remaining capacity of all the bins, multiplied by the item size raised to the power of the bin index divided by twice the item size, and finally multiplied by a factor that is the exponential function of the item size plus 1, raised to the power of the square root of the item size, divided by the square root of the sum of all bin capacities, and then multiplied by a constant factor of 10.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.sqrt(remaining_capacity) / np.sqrt(min_remaining_capacity)) * (item ** (np.arange(len(bins)) / (2 * item))) * ((np.exp(item + 1) ** np.sqrt(item)) / np.sqrt(sum_bin_capacities)) * 10\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin by dividing the logarithm of the remaining capacity of each bin by the logarithm of the minimum remaining capacity of all the bins, and multiplying it by the cubic root of the item size raised to the power of the bin index divided by the cubic root of the sum of all bin capacities. Finally, the scores will be multiplied by the exponential function of the item size plus 3, raised to the power of the cubic root of the item size divided by the sum of all bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n sum_bin_capacities = np.sum(bins)\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * ((item ** (1/3)) ** (np.arange(len(bins)) / (sum_bin_capacities ** (1/3)))) * ((np.exp(item + 3) ** (item ** (1/3))) / (sum_bin_capacities))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity of all the bins, multiplied by the square root of the bin index times the item size raised to the power of the square root of the bin index, and finally multiplied by a factor that is the exponential function of the sum of the item size and 1, raised to the power of the square root of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n min_remaining_capacity = np.min(remaining_capacity)\\n bin_index = np.arange(len(bins))\\n scores = (np.log(remaining_capacity) / np.log(min_remaining_capacity)) * (np.sqrt(bin_index) * (item ** np.sqrt(bin_index))) * (np.exp(item + 1) ** np.sqrt(item))\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the exponential function raised to the power of the logarithm of the remaining capacity of each bin divided by the logarithm of the minimum remaining capacity among all the bins, multiplied by the item size to the power of the square root of the bin index, and finally multiplied by the item size divided by the sum of the square root of the remaining capacities of all the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n min_remaining_capacity = np.min(bins - item)\\n scores = (np.exp(np.log(bins - item) / np.log(min_remaining_capacity))) * (item ** np.sqrt(np.arange(len(bins)) + 1)) * (item / np.sum(np.sqrt(bins)))\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign an item to a bin by calculating scores for each bin based on the remaining capacity and item size, with different parameter settings for the score function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2*item - bins) / (item + bins)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The modified scoring function takes into account the square root of the rest capacity, subtracted by the item size, and the reciprocal of the logarithm of the proximity to the item size. The scores are then returned as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins - item) - item) / (1 / np.log(item / (1 + np.arange(len(bins)))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the remaining capacity of the bin and the size of the item, with a higher ratio indicating a better score. This is done to prioritize bins that have more remaining capacity relative to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.where(ratios > 1, 0, 1/ratios)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns a score to each bin based on the inverse of the ratio of the item size to the rest capacity of the bin, subtracting the bin's index multiplied by a penalty factor of 0.1, and returning a Numpy array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = ratios - (0.1 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size subtracted by the number of times the current item size can fit completely into the bin, favoring bins with higher ratios and lower indexes, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n fit_count = np.floor(bins / item)\\n scores = (ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins))) - fit_count\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, prioritizing bins with higher ratios and lower indexes, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, with higher ratios being prioritized, but also giving weightage to the index of the bin by subtracting the index multiplied by a constant value from the score.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = ratios - (np.arange(len(bins)) * 0.5)\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the sum of the squared differences between the item size and the remaining capacity of the bins to promote performance. It then returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum((item - bins)**2)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.where(bins == bins.max(), 0, bins / np.maximum((bins - item), 1))\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on a combination of factors including the product of the rest capacity ratio and the item size, the index of the bin, and the exponential of the item size divided by the rest capacity. The algorithm prioritizes bins with higher rest capacity ratios, lower indexes, and larger scores computed using the above factors, returning a Numpy array of scores for assignment.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacity_ratios = bins / item\\n exponential_ratios = np.exp(item / bins)\\n scores = (rest_capacity_ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins))) + exponential_ratios\\n return scores\",\n \"objective\": 0.04326,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a linear combination of factors including the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently. The algorithm prioritizes bins with higher ratios, lower indexes, and larger logarithmic scores, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (3 * ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins))) + 0.5 * np.log(np.maximum(ratios, 1e-8))\\n return scores\",\n \"objective\": 0.04367,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of factors including the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio of the rest capacity to the item size. The algorithm prioritizes bins with higher ratios, lower indexes, and larger logarithmic scores, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n scores = (ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins))) + log_ratios\\n return scores\",\n \"objective\": 0.04377,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on the rest capacity to the item size ratio, incorporating a logarithmic function to amplify the effect of small differences in ratios, while also considering the index of the bin by subtracting the index multiplied by a constant value from the score. Additionally, it penalizes bins with larger capacities to encourage the utilization of smaller bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.log(ratios + 1e-6) - (np.arange(len(bins)) * 0.5) - (1 / bins)\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns a score to each bin based on a modified ratio of the rest capacity to the item size, incorporating a logarithmic function to amplify the effect of small differences in ratios, while also considering the index of the bin by subtracting the index multiplied by a constant value from the score.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.log(ratios + 1e-6) - (np.arange(len(bins)) * 0.5)\\n return scores\",\n \"objective\": 0.04437,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on the ratio of the rest capacity to the item size.\\n\\nNew algorithm: \\nThe new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, but also considers the square of the index of the bin, the logarithm of the ratio, and a constant factor, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, larger logarithmic scores, and to minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n index_squared = np.square(np.arange(len(bins)))\\n scores = (4 * ratios * (bins == np.max(bins))) - (2 * index_squared) + (0.5 * log_ratios) + 0.1\\n return scores\",\n \"objective\": 0.04528,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns a score to each bin based on a combination of factors including the square root of the rest capacity divided by the item size, the index of the bin, and the inverse of the logarithm of the item size divided by the rest capacity. The algorithm prioritizes bins with higher square root ratios, lower indexes, and larger scores computed using the above factors, returning a Numpy array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sqrt_ratios = np.sqrt(bins/item)\\n log_ratios = np.log(item/bins)\\n scores = (sqrt_ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins))) + (1/log_ratios)\\n return scores\",\n \"objective\": 0.04739,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, the logarithm of the item size divided by the rest capacity, and the square of the index of the bin, combined with an exponential decay factor and a constant term, with each factor being weighted differently, to prioritize bins with higher ratios, smaller logarithmic scores, lower indexes, and to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(item / bins)\\n index_squared = np.square(np.arange(len(bins)))\\n decay_factor = 0.8\\n constant_term = 0.5\\n scores = (ratios**2 * np.exp(-decay_factor * index_squared)) - (1/log_ratios) + constant_term\\n return scores\",\n \"objective\": 0.04759,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of factors including the square root of the rest capacity divided by the item size, the index of the bin multiplied by the cube root of the item size, and the inverse of the logarithm of the item size divided by the rest capacity. The algorithm prioritizes bins with higher square root ratios, lower index values, and larger scores computed using the above factors, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sqrt_ratios = np.sqrt(bins/item)\\n index_factors = np.arange(len(bins)) * np.cbrt(item)\\n log_ratios = np.log(item/bins)\\n scores = (sqrt_ratios * (bins == np.max(bins))) - index_factors + (1/log_ratios)\\n return scores\",\n \"objective\": 0.04789,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scale_factor = 1.0 / max_bin_cap\\n scores = (bins - max_bin_cap) ** 2 * scale_factor\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.sum(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms assign scores to bins based on the ratio of rest capacity to item size, and use different combinations of factors and functions to prioritize bins with larger ratios and promote better performance in the scoring function.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the cube of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 2.2)\\n scores = (bins * np.sqrt(item) - 3 * np.power(indices, 1.4) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (6 * np.power(ratios, 3))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + 1 / np.log(bins / item + 1e-8) - 2 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the ratio between the item size and the remaining capacities of the bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n capacity_ratio = item / bins # Calculate the ratio between the item size and the remaining capacities of the bins\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n\\n # Additional step: Adjust scores based on the ratio between the item size and the remaining capacities of the bins\\n scores *= capacity_ratio\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the natural logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 3 * indices\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a quadratic function of the index, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8))) + (0.75 * np.power(indices, 2))\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the sum of the capacities of consecutively assigned bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n # Additional step: Adjust scores based on the sum of capacities of consecutive bins\\n scores /= np.cumsum(bins)\\n \\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * indices) + (0.5 / np.log(bins - item + 1e-8))\\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the square root of the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.sqrt(np.log(np.maximum(bins / item, 1e-8))) - 3 * indices\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 2 * bins - 3 * np.power(indices, 2) + 0.5 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a polynomial function consisting of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (5 * np.power(ratios, 3)) - (4 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 3 * bins - 2 * np.power(indices, 2) + 1 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms assign scores to bins based on the ratio of rest capacity to item size, and use different combinations of factors and functions to prioritize bins with larger ratios and promote better performance in the scoring function.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the cube of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 2.2)\\n scores = (bins * np.sqrt(item) - 3 * np.power(indices, 1.4) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (6 * np.power(ratios, 3))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + 1 / np.log(bins / item + 1e-8) - 2 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the ratio between the item size and the remaining capacities of the bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n capacity_ratio = item / bins # Calculate the ratio between the item size and the remaining capacities of the bins\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n\\n # Additional step: Adjust scores based on the ratio between the item size and the remaining capacities of the bins\\n scores *= capacity_ratio\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the natural logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 3 * indices\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a quadratic function of the index, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8))) + (0.75 * np.power(indices, 2))\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the sum of the capacities of consecutively assigned bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n # Additional step: Adjust scores based on the sum of capacities of consecutive bins\\n scores /= np.cumsum(bins)\\n \\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm randomly assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n random_scores = np.random.uniform(0, 1, len(bins))\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n scores = scores * random_scores # Randomly assign scores to bins\\n return scores\",\n \"objective\": 0.01972,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * indices) + (0.5 / np.log(bins - item + 1e-8))\\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the square root of the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.sqrt(np.log(np.maximum(bins / item, 1e-8))) - 3 * indices\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scaled_item = item / max_bin_cap\\n scores = (bins - max_bin_cap) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm first calculates the average capacity of the bins, and then computes the score for each bin based on the item and the bin capacities using a modified formula. It adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nImplementing it in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.mean(bins)\\n scores = (bins - avg_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item to bins\\n ratio = item / bins\\n\\n # Apply a logarithm to the ratio and add a small epsilon value to avoid division by zero\\n log_ratio = np.log(ratio + 1e-8)\\n\\n # Subtract 2 times the range of bins from the logarithm\\n scores = bins + 1 / log_ratio - 2 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 3 * bins - 2 * np.power(indices, 2) + 1 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 2\\n scores *= np.where(bins > item, -1, 1)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms assign scores to bins based on the ratio of rest capacity to item size, and use different combinations of factors and functions to prioritize bins with larger ratios and promote better performance in the scoring function.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the cube of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 2.2)\\n scores = (bins * np.sqrt(item) - 3 * np.power(indices, 1.4) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (6 * np.power(ratios, 3))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + 1 / np.log(bins / item + 1e-8) - 2 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a modified formula, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the ratio between the item size and the remaining capacities of the bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n capacity_ratio = item / bins\\n \\n scores = ((bins**2) / (item**3)) + ((bins - max_bin_cap)**2 / item) + ((bins**2) / (item**2))\\n scores[bins > item] = -scores[bins > item]\\n \\n scores[1:] -= scores[:-1]\\n scores *= capacity_ratio\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the natural logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 3 * indices\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a quadratic function of the index, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8))) + (0.75 * np.power(indices, 2))\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the sum of the capacities of consecutively assigned bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n # Additional step: Adjust scores based on the sum of capacities of consecutive bins\\n scores /= np.cumsum(bins)\\n \\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n MAX_SCALE = 100\\n scaled_item = item / MAX_SCALE\\n scores = (bins - max(bins)) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores *= np.where(bins > item, -0.5, 1)\\n scores[1:] -= scores[:-1]\\n scores /= np.max(np.abs(scores)) + 1e-8\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm first calculates the average capacity of the bins, and then computes the score for each bin based on the item and the bin capacities using a modified formula. It adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nImplementing it in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.mean(bins)\\n scores = (bins - avg_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item to bins\\n ratio = item / bins\\n\\n # Apply a logarithm to the ratio and add a small epsilon value to avoid division by zero\\n log_ratio = np.log(ratio + 1e-8)\\n\\n # Subtract 2 times the range of bins from the logarithm\\n scores = bins + 1 / log_ratio - 2 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the square root of the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.sqrt(np.log(np.maximum(bins / item, 1e-8))) - 2 * indices\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 3 * bins - 2 * np.power(indices, 2) + 1 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 2\\n scores *= np.where(bins > item, -1, 1)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms assign scores to bins based on the ratio of rest capacity to item size, and use different combinations of factors and functions to prioritize bins with larger ratios and promote better performance in the scoring function.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the cube of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 2.2)\\n scores = (bins * np.sqrt(item) - 3 * np.power(indices, 1.4) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (6 * np.power(ratios, 3))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + 1 / np.log(bins / item + 1e-8) - 2 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01197,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a modified formula, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the ratio between the item size and the remaining capacities of the bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n capacity_ratio = item / bins\\n \\n scores = ((bins**2) / (item**3)) + ((bins - max_bin_cap)**2 / item) + ((bins**2) / (item**2))\\n scores[bins > item] = -scores[bins > item]\\n \\n scores[1:] -= scores[:-1]\\n scores *= capacity_ratio\\n \\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the natural logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 3 * indices\\n return scores\",\n \"objective\": 0.01761,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - max_capacity) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-(bins - item) / max_capacity)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n MAX_SCALE = 100\\n scaled_item = item / MAX_SCALE\\n scores = (bins - max(bins)) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n scores = (bins * np.cbrt(item) - 3 * np.power(indices, 1.5) + (1 / np.log(np.maximum(ratios, 1e-8))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm first calculates the average capacity of the bins, and then computes the score for each bin based on the item and the bin capacities using a modified formula. It adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nImplementing it in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.mean(bins)\\n scores = (bins - avg_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/3)) - 3 * (np.arange(len(bins)) ** 1.5) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the logarithm of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/2)) - (np.arange(len(bins)) ** 2) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate a score for each bin based on the comparison between the rest capacity of the bin and the size of the item.\\n\\nNew algorithm description: My new algorithm assigns a score to each bin based on the ratio between the rest capacity of the bin and the size of the item, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (bins - item) * np.abs(log_ratios - np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item to bins\\n ratio = item / bins\\n\\n # Apply a logarithm to the ratio and add a small epsilon value to avoid division by zero\\n log_ratio = np.log(ratio + 1e-8)\\n\\n # Subtract 2 times the range of bins from the logarithm\\n scores = bins + 1 / log_ratio - 2 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the square root of the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.sqrt(np.log(np.maximum(bins / item, 1e-8))) - 2 * indices\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 3 * bins - 2 * np.power(indices, 2) + 1 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio between the rest capacity of the bin and the size of the item, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (np.power(ratios, 2) * (bins - item) * np.abs(log_ratios - np.log(item))) - 2 * np.power(np.arange(len(bins)), 2) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 2\\n scores *= np.where(bins > item, -1, 1)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the inverse of the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the exponential differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity / (bins + 1)) ** 2\\n scores *= np.where(bins > item, -1, 1)\\n scores[1:] -= scores[:-1]\\n scores = np.exp(scores)\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"New algorithm: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((bins - max_capacity) ** 2) / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-((bins - item) / max_capacity) ** 2)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - max_capacity) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-(bins - item) / max_capacity)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n MAX_SCALE = 100\\n scaled_item = item / MAX_SCALE\\n scores = (bins - max(bins)) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n scores = (bins * np.cbrt(item) - 3 * np.power(indices, 1.5) + (1 / np.log(np.maximum(ratios, 1e-8))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm first calculates the average capacity of the bins, and then computes the score for each bin based on the item and the bin capacities using a modified formula. It adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nImplementing it in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.mean(bins)\\n scores = (bins - avg_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/3)) - 3 * (np.arange(len(bins)) ** 1.5) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the logarithm of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/2)) - (np.arange(len(bins)) ** 2) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its comparison with the item size and the rest capacities of the bins. \\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on the ratio of the square root of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(item) / np.sqrt(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate a score for each bin based on the comparison between the rest capacity of the bin and the size of the item.\\n\\nNew algorithm description: My new algorithm assigns a score to each bin based on the ratio between the rest capacity of the bin and the size of the item, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (bins - item) * np.abs(log_ratios - np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of item to bins\\n ratio = item / bins\\n\\n # Calculate the logarithm of the ratio\\n log_ratio = np.log(ratio)\\n\\n # Calculate the scores for the bins for assignment\\n scores = bins + 1 / log_ratio - 2 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the square root of the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.sqrt(np.log(np.maximum(bins / item, 1e-8))) - 2 * indices\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 3 * bins - 2 * np.power(indices, 2) + 1 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the ratio between the rest capacity of the bin and the size of the item, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (np.power(ratios, 2) * (bins - item) * np.abs(log_ratios - np.log(item))) - 2 * np.power(np.arange(len(bins)), 2) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"New algorithm: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((bins - max_capacity) ** 2) / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-((bins - item) / max_capacity) ** 2)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - max_capacity) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-(bins - item) / max_capacity)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n MAX_SCALE = 100\\n scaled_item = item / MAX_SCALE\\n scores = (bins - max(bins)) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: This novel algorithm calculates a score for each bin based on the ratio of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores while incorporating an additional step to penalize bins with larger remaining capacities and promote performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-((bins - item) / max_capacity) ** 2)\\n scores[1:] -= scores[:-1]\\n scores[1:] -= np.arange(1, len(bins)) / np.max(bins)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n scores = (bins * np.cbrt(item) - 3 * np.power(indices, 1.5) + (1 / np.log(np.maximum(ratios, 1e-8))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm first calculates the average capacity of the bins, and then computes the score for each bin based on the item and the bin capacities using a modified formula. It adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nImplementing it in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.mean(bins)\\n scores = (bins - avg_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This new algorithm calculates a score for a given item based on the product of the item size and the inverse of the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins)\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the logarithm of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/2)) - (np.arange(len(bins)) ** 2) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All the provided algorithms calculate a score for each bin based on the comparison between the rest capacity of the bin and the size of the item.\\n\\nNew Algorithm Description: My new algorithm assigns a score to each bin based on a complex combination of the ratio between the rest capacity of the bin and the size of the item, the sum of the logarithms of both the bin capacity and the item size, and a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins. (mathematical expression)\\n\\nCode Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (bins - item) * np.abs(log_ratios + np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its comparison with the item size and the rest capacities of the bins. \\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on the ratio of the square root of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 0.5\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate a score for each bin based on the comparison between the rest capacity of the bin and the size of the item.\\n\\nNew algorithm description: My new algorithm assigns a score to each bin based on the ratio between the rest capacity of the bin and the size of the item, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (bins - item) * np.abs(log_ratios - np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe new algorithm calculates a score for a given item based on the ratio of the cube root of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item by taking the logarithm of the scores, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.cbrt(item) / np.cbrt(bins)\\n scores[bins > item] = -np.log(scores[bins > item])\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nThe new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nCode implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins) # Determine maximum capacity of the bins\\n scores = ((bins - max_capacity) ** 2 / item) # Compute initial scores using a formula involving the bins and item\\n \\n scores[bins > item] = -scores[bins > item] # Adjust scores for bins greater than the item\\n \\n scores[1:] -= scores[:-1] # Update scores based on differences between consecutive elements\\n \\n max_remaining_capacity = np.max(bins) - item # Calculate the maximum remaining capacity of the bins\\n \\n scores -= np.abs(bins - max_remaining_capacity) # Penalize bins with larger remaining capacities\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the square root of the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.sqrt(np.log(np.maximum(bins / item, 1e-8))) - 2 * indices\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"New algorithm: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((bins - max_capacity) ** 2) / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-((bins - item) / max_capacity) ** 2)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nCode implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / (item + 1) # Modified formula: adding 1 to the item size\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities - Unchanged\\n scores -= abs(scores) / item # Additional change to penalize higher scores - Unchanged\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The algorithm further enhances the original algorithm by incorporating an additional step that penalizes bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/np.min(bins) # Penalty for smaller remaining capacities\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nMain steps of the new algorithm:\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using the formula: \\n - Subtract the maximum capacity from the remaining capacity of each bin and square the result.\\n - Divide the squared difference by the size of the current item.\\n - If the remaining capacity of a bin is greater than the current item, multiply the score by -1.\\n - Multiply the score by the exponential of the negative difference between the remaining capacity of the bin and the size of the current item divided by the maximum capacity.\\n3. Adjust the scores by subtracting the score of the previous bin from the score of the current bin.\\n4. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - max_capacity) ** 2 / item\\n scores[bins > item] *= -1\\n scores *= np.exp(-(bins - item) / max_capacity)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities - Unchanged\\n scores -= abs(scores) / item # Additional change to penalize higher scores\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n MAX_SCALE = 100\\n scaled_item = item / MAX_SCALE\\n scores = (bins - max(bins)) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mean_value = np.mean(bins) # calculating the mean of 'bins'\\n scores = (bins - mean_value) ** 2 / item # using mean_value instead of np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n scores = (bins * np.cbrt(item) - 3 * np.power(indices, 1.5) + (1 / np.log(np.maximum(ratios, 1e-8))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm first calculates the average capacity of the bins, and then computes the score for each bin based on the item and the bin capacities using a modified formula. It adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nImplementing it in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.mean(bins)\\n scores = (bins - avg_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This new algorithm calculates a score for a given item based on the product of the item size and the inverse of the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins)\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the logarithm of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/2)) - (np.arange(len(bins)) ** 2) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All the provided algorithms calculate a score for each bin based on the comparison between the rest capacity of the bin and the size of the item.\\n\\nNew Algorithm Description: My new algorithm assigns a score to each bin based on a complex combination of the ratio between the rest capacity of the bin and the size of the item, the sum of the logarithms of both the bin capacity and the item size, and a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins. (mathematical expression)\\n\\nCode Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (bins - item) * np.abs(log_ratios + np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its comparison with the item size and the rest capacities of the bins. \\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on the ratio of the square root of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 0.5\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate a score for each bin based on the comparison between the rest capacity of the bin and the size of the item.\\n\\nNew algorithm description: My new algorithm assigns a score to each bin based on the ratio between the rest capacity of the bin and the size of the item, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (bins - item) * np.abs(log_ratios - np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New algorithm: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((bins - max_capacity) ** 2) / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-((bins - item) / max_capacity) ** 2)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nCode implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / (item + 1) # Modified formula: adding 1 to the item size\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities - Unchanged\\n scores -= abs(scores) / item # Additional change to penalize higher scores - Unchanged\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The algorithm further enhances the original algorithm by incorporating an additional step that penalizes bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/np.min(bins) # Penalty for smaller remaining capacities\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nMain steps of the new algorithm:\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using the formula: \\n - Subtract the maximum capacity from the remaining capacity of each bin and square the result.\\n - Divide the squared difference by the size of the current item.\\n - If the remaining capacity of a bin is greater than the current item, multiply the score by -1.\\n - Multiply the score by the exponential of the negative difference between the remaining capacity of the bin and the size of the current item divided by the maximum capacity.\\n3. Adjust the scores by subtracting the score of the previous bin from the score of the current bin.\\n4. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - max_capacity) ** 2 / item\\n scores[bins > item] *= -1\\n scores *= np.exp(-(bins - item) / max_capacity)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities - Unchanged\\n scores -= abs(scores) / item # Additional change to penalize higher scores\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n MAX_SCALE = 100\\n scaled_item = item / MAX_SCALE\\n scores = (bins - max(bins)) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mean_value = np.mean(bins) # calculating the mean of 'bins'\\n scores = (bins - mean_value) ** 2 / item # using mean_value instead of np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * np.cbrt(item) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / np.log(np.maximum(ratios, 1e-8))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate a score for each bin based on the comparison between the bin's capacity and the item's size.\\n\\nNew algorithm description: The new algorithm calculates a score for each bin based on a modified formula that takes into account the ratio of the item's size to the bin's capacity, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt((item * (1 / bins))**3) # Modified formula\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This new algorithm calculates a score for a given item based on the product of the item size and the inverse of the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins)\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the logarithm of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/2)) - (np.arange(len(bins)) ** 2) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All the provided algorithms calculate a score for each bin based on the comparison between the rest capacity of the bin and the size of the item.\\n\\nNew Algorithm Description: My new algorithm assigns a score to each bin based on a complex combination of the ratio between the rest capacity of the bin and the size of the item, the sum of the logarithms of both the bin capacity and the item size, and a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins. (mathematical expression)\\n\\nCode Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios + 1e-8)\\n scores = (bins - item) * np.abs(log_ratios + np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its comparison with the item size and the rest capacities of the bins. \\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on the ratio of the square root of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 0.5\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on the ratio between the rest capacity of the bin and the square root of the item size, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n scores = (bins - item) * np.abs(log_ratios - np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"New algorithm: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((bins - max_capacity) ** 2) / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-((bins - item) / max_capacity) ** 2)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nCode implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / (item + 1) # Modified formula: adding 1 to the item size\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities - Unchanged\\n scores -= abs(scores) / item # Additional change to penalize higher scores - Unchanged\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The algorithm further enhances the original algorithm by incorporating an additional step that penalizes bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/np.min(bins) # Penalty for smaller remaining capacities\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate a score for each bin based on its comparison with the item and other bins, adjust the scores for bins greater than the item, update the scores based on differences between consecutive elements, and return the resulting scores.\\n\\nNew algorithm description: This modified algorithm calculates a score for a given item based on the item's comparison with a list of bins, penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores *= np.exp(-(bins - item) / max_bin_cap)\\n scores[bins > item] *= -1\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This modified algorithm calculates a score for a given item based on the item's comparison with a list of bins, penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nImplementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores += (bins - max_bin_cap) / max_bin_cap\\n scores[bins > item] *= -1\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n MAX_SCALE = 100\\n scaled_item = item / MAX_SCALE\\n scores = (bins - max(bins)) ** 2 / scaled_item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mean_value = np.mean(bins) # calculating the mean of 'bins'\\n scores = (bins - mean_value) ** 2 / item # using mean_value instead of np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate scores for each bin based on a comparison with the item size and the rest capacities of the bins.\\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] *= -1\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a weighted formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins * item * (max_capacity / bins) ** 2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * np.cbrt(item) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / np.log(np.maximum(ratios, 1e-8))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate a score for each bin based on the comparison between the bin's capacity and the item's size.\\n\\nNew algorithm description: The new algorithm calculates a score for each bin based on a modified formula that takes into account the ratio of the item's size to the bin's capacity, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt((item * (1 / bins))**3)\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This new algorithm calculates a score for a given item based on the product of the item size and the inverse of the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins)\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the logarithm of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/2)) - (np.arange(len(bins)) ** 2) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusting the scores for bins greater than the item, updating the scores based on quadratic differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores[1:] -= np.square(scores[:-1])\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its comparison with the item size and the rest capacities of the bins. \\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on the ratio of the square root of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) ** 0.5\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on the ratio between the rest capacity of the bin and the square root of the item size, multiplied by the absolute difference between the logarithm of the rest capacity and the logarithm of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n scores = (bins - item) * np.abs(log_ratios - np.log(item)) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / log_ratios) - (5 * np.power(ratios, 2))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (1 / ratios) - (np.sqrt(indices)) + np.exp(log_ratios)\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalize bins with maximum capacity, and prioritize bins with minimum remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n scores += (min_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (2 * ratios * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the remaining capacity of the bin and the size of the item, with a higher ratio indicating a better score. This is done to prioritize bins that have more remaining capacity relative to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (bins / item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The modified scoring function takes into account the square root of the rest capacity, subtracted by the item size, and the reciprocal of the logarithm of the proximity to the item size. The scores are then returned as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins - item) - item) / (1 / np.log(item / (1 + np.arange(len(bins)))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of exponential and logarithmic functions to calculate the scores for each bin, considering the rest capacity of the bin and the item size, and penalizing bins with larger capacities to encourage the utilization of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-(bins - item) / (np.log10(item + np.arange(1, len(bins)+1))))\\n scores *= (1 / bins)\\n scores *= np.exp(-np.arange(len(bins)) * 0.1)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the remaining capacity of the bin and the size of the item, with a higher ratio indicating a better score. This is done to prioritize bins that have more remaining capacity relative to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.where(ratios > 1, 0, 1/ratios)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns a score to each bin based on the inverse of the ratio of the item size to the rest capacity of the bin, subtracting the bin's index multiplied by a penalty factor of 0.1, and returning a Numpy array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = ratios - (0.1 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size subtracted by the number of times the current item size can fit completely into the bin, favoring bins with higher ratios and lower indexes, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n fit_count = np.floor(bins / item)\\n scores = (ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins))) - fit_count\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin by calculating the product of the bin capacity divided by the item size and a constant factor, and then subtracting the index of the bin multiplied by another constant factor from the score.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * 0.8 - (np.arange(len(bins)) * 0.3)\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, where higher ratios are given more weightage, and the index of the bin is also considered by subtracting a weighted index value from the score. Additionally, a penalty term is introduced to decrease the score for bins that are close to their maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins)) * 0.5\\n penalties = (bins == np.max(bins)) * 0.1 # Penalty term decreases score for bins at their maximum capacity\\n scores = ratios - weights - penalties\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by taking the product of the bin's rest capacity divided by the item size, subtracting the index of the bin multiplied by a penalty factor, and adding a decayed logarithmic term based on the ratio of the item size to the rest capacity of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins) - (0.2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the ratio of the logarithm of the item size plus one divided by the rest capacity of the bin, multiplied by a penalty factor calculated as the exponential of the negative value of the bin index multiplied by a variable penalty coefficient, aiming to maximize the utilization of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_coefficient = 0.2\\n scores = (item / bins) * np.exp(-np.arange(len(bins)) * penalty_coefficient)\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the sum of the squared differences between the item size and the remaining capacity of the bins to promote performance. It then returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sum((item - bins)**2)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's rest capacity, the item size, and a penalty for larger capacities, aiming to maximize the utilization of smaller bins.\\n\\nThe main steps of the algorithm are as follows:\\n1. Calculate the ratio of the item size to the rest capacity of each bin, and raise it to a power of 2.\\n2. Multiply the result by the logarithm of the item size plus 1, divided by the bin index plus 1.\\n3. Multiply the result by a penalty factor calculated as the exponential of the negative value of the bin index multiplied by 0.1.\\n4. Divide the result by the rest capacity of each bin.\\n\\nThe resulting scores are then returned as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (item / bins)**2\\n scores *= np.log10(item + 1) / (np.arange(len(bins)) + 1)\\n scores *= np.exp(-np.arange(len(bins)) * 0.1)\\n scores /= bins\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the given algorithms calculate scores for each bin based on the ratio of the rest capacity to the item size, and consider the index/position of the bin in the scoring process.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on a combination of the bin's rest capacity, the item size, and a penalty for larger capacities, aiming to maximize the utilization of smaller bins, while also considering the index/position of the bin.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.log10(ratios) / (np.arange(len(bins)) + 1)\\n scores *= np.exp(-np.arange(len(bins)) * 0.2)\\n scores -= np.arange(len(bins)) * 0.1\\n scores += (bins != np.max(bins)) * 0.5\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by taking the product of the bin's rest capacity divided by the item size, subtracting the index of the bin multiplied by a penalty factor, and adding a decayed logarithmic term based on the ratio of the item size to the rest capacity of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (0.2 * np.arange(len(bins)))\\n scores += np.log10(item / bins) * 0.5\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, with lower ratios being given more weightage, and the index of the bin is also considered by adding a weighted index value to the score. Additionally, a bonus term is introduced to increase the score for bins that are far from their maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins)) * 0.5\\n bonuses = (bins != np.max(bins)) * 0.05 # Bonus term increases score for bins that are far from their maximum capacity\\n scores = -ratios + weights + bonuses # Negative ratio to give more weightage to lower ratios\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"New algorithm: This modified algorithm calculates a score for a given item based on its comparison with a list of bins with the same maximum capacity. The algorithm computes a score using a modified formula that penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nNew code implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = ((bins - max_capacity) ** 2) / item\\n scores[bins > item] = -scores[bins > item]\\n scores *= np.exp(-((bins - item) / max_capacity) ** 2)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All the algorithms calculate a score for each bin based on a formula involving the rest capacities of the bins and the size of the item.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a modified formula involving the rest capacities of the bins, the size of the item, and a non-linear combination of the ratio of the rest capacity to the item size, with the goal of minimizing the number of used bins.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n ratios = bins / item\\n scores = (bins - max_bin_cap) ** 2 / item + (ratios ** 2) - (np.log(ratios) / (ratios ** 2))\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with larger remaining capacities, and finally returning the resulting scores.\\n\\nCode implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / (item + 1) # Modified formula: adding 1 to the item size\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities - Unchanged\\n scores -= abs(scores) / item # Additional change to penalize higher scores - Unchanged\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The algorithm further enhances the original algorithm by incorporating an additional step that penalizes bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/np.min(bins) # Penalty for smaller remaining capacities\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins/10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, penalizing bins with remaining capacities below a certain threshold, and finally returning the resulting scores.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n bin_capacity_diff = bins - item\\n\\n scores = (bins - max_bin_cap)**2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n\\n threshold = 0.5 * max_bin_cap\\n lower_capacity_scores = -0.1 * np.where(bin_capacity_diff < threshold, threshold - bin_capacity_diff, 0)\\n scores = scores + lower_capacity_scores\\n\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate a score for each bin based on its comparison with the item and other bins, adjust the scores for bins greater than the item, update the scores based on differences between consecutive elements, and return the resulting scores.\\n\\nNew algorithm description: This modified algorithm calculates a score for a given item based on the item's comparison with a list of bins, penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores *= np.exp(-(bins - item) / max_bin_cap)\\n scores[bins > item] *= -1\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This modified algorithm calculates a score for a given item based on the item's comparison with a list of bins, penalizes bins with larger remaining capacities, adjusts the scores for bins greater than the item, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\\n\\nImplementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores += (bins - max_bin_cap) / max_bin_cap\\n scores[bins > item] *= -1\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The algorithm further enhances the original algorithm by incorporating an additional step that penalizes bins with smaller remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins) / item # Normalize the max_bin_cap\\n bins = bins / item # Normalize the bins\\n scores = (bins - max_bin_cap)**2\\n scores[bins > 1] = -scores[bins > 1]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. This algorithm further enhances the original algorithm by incorporating an additional step to penalize bins with larger remaining capacities.\\n\\nCode implementation:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for a given item based on its comparison with a list of bins, involving the maximum capacity of the bins, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and penalizing bins with larger remaining capacities.\\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a weighted formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and penalizing bins with larger remaining capacities.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = bins * item * (max_bin_cap / bins) ** 2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= bins / 10 # Penalty for larger remaining capacities\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins)) ** 2 / np.max(bins)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate scores for each bin based on a comparison with the item size and the rest capacities of the bins.\\n\\nNew algorithm description: This new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] *= -1\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a weighted formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins * item * (max_capacity / bins) ** 2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns a score to each bin based on the product of the rest capacity and the cube root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * np.cbrt(item) - 3 * np.power(np.arange(len(bins)), 1.5) + (1 / np.log(np.maximum(ratios, 1e-8))))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate a score for each bin based on the comparison between the bin's capacity and the item's size.\\n\\nNew algorithm description: The new algorithm calculates a score for each bin based on a modified formula that takes into account the ratio of the item's size to the bin's capacity, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt((item * (1 / bins))**3)\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This new algorithm calculates a score for a given item based on the product of the item size and the inverse of the rest capacities of the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item * (1 / bins)\\n scores[bins > item] *= -1\\n scores = np.diff(scores, prepend=0)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the logarithm of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = (bins * (item ** (1/2)) - (np.arange(len(bins)) ** 2) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (5 * ratios)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on the ratio of the item size to the rest capacities of the bins, adjusting the scores for bins greater than the item, updating the scores based on quadratic differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores[1:] -= np.square(scores[:-1])\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins. It then computes a score for each bin using a formula involving the bins and the item, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (1 / ratios) - (np.sqrt(indices)) + np.exp(log_ratios)\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a modified combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a power and weighted differently, to further prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (1 / ratios)**2 - np.sqrt(indices)**3 + np.exp(log_ratios)**4\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalize bins with maximum capacity, and prioritize bins with minimum remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n scores += (min_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by calculating the product of the bin's rest capacity divided by the item size, the inverse of the logarithm of the ratio, and a penalization factor based on the square root of the index of the bin multiplied by the maximum capacity of the bins.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (bins / item) * (1 / np.log(log_ratios + 1)) - np.sqrt(indices) * np.sqrt(max_bin_cap)\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (2 * ratios * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by taking the product of the bin's rest capacity divided by the item size, subtracting the index of the bin multiplied by a penalty factor, and adding a decayed logarithmic term based on the ratio of the item size to the rest capacity of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the product of the logarithm of the item size plus 2, the exponential of the negative value of the bin index multiplied by 0.1, and the ratio of the item size to the rest capacity of each bin raised to a power of 3, divided by the rest capacity of each bin.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log10(item + 2) * np.exp(-np.arange(len(bins)) * 0.1) * ((item / bins) ** 3)) / bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the product of the logarithm of the item size plus 1, the exponential of the negative value of the bin index multiplied by 0.1, and the ratio of the item size to the rest capacity of each bin raised to a power of 2, divided by the rest capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log10(item + 1) * np.exp(-np.arange(len(bins)) * 0.1) * ((item / bins) ** 2)) / bins\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The modified scoring function takes into account the square root of the rest capacity, subtracted by the item size, and the reciprocal of the logarithm of the proximity to the item size. The scores are then returned as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins - item) - item) / (1 / np.log(item / (1 + np.arange(len(bins)))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a combination of exponential and logarithmic functions to calculate the scores for each bin, considering the rest capacity of the bin and the item size, and penalizing bins with larger capacities to encourage the utilization of smaller bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(-(bins - item) / (np.log10(item + np.arange(1, len(bins)+1))))\\n scores *= (1 / bins)\\n scores *= np.exp(-np.arange(len(bins)) * 0.1)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio between the remaining capacity of the bin and the size of the item, with a higher ratio indicating a better score. This is done to prioritize bins that have more remaining capacity relative to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n scores = np.where(ratios > 1, 0, 1/ratios)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns a score to each bin based on the inverse of the ratio of the item size to the rest capacity of the bin, subtracting the bin's index multiplied by a penalty factor of 0.1, and returning a Numpy array of scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = ratios - (0.1 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size subtracted by the number of times the current item size can fit completely into the bin, favoring bins with higher ratios and lower indexes, and returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n fit_count = np.floor(bins / item)\\n scores = (ratios * (bins == np.max(bins))) - (2 * np.arange(len(bins))) - fit_count\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin by calculating the product of the bin capacity divided by the item size and a constant factor, and then subtracting the index of the bin multiplied by another constant factor from the score.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) * 0.8 - (np.arange(len(bins)) * 0.3)\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, where higher ratios are given more weightage, and the index of the bin is also considered by subtracting a weighted index value from the score. Additionally, a penalty term is introduced to decrease the score for bins that are close to their maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins)) * 0.5\\n penalties = (bins == np.max(bins)) * 0.1 # Penalty term decreases score for bins at their maximum capacity\\n scores = ratios - weights - penalties\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin by taking the product of the bin's rest capacity divided by the item size, subtracting the index of the bin multiplied by a penalty factor, and adding a decayed logarithmic term based on the ratio of the item size to the rest capacity of the bin with the following parameter settings:\\n- The penalty factor is set to 0.3.\\n- The decayed logarithmic term is calculated as 2 * log(1 + (item / bins)).\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_factor = 0.3\\n decayed_log_term = 2 * np.log(1 + (item / bins))\\n scores = (item / bins) - (penalty_factor * np.arange(len(bins))) + decayed_log_term\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins. It then computes a score for each bin using a formula involving the bins and the item, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and finally returns the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the given algorithms calculate scores for each bin based on their capacities and the item size, and adjust those scores based on certain conditions to prioritize certain bins.\\n\\nNew Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity multiplied by the square root of the index of the bin, the reciprocal of the logarithm of the ratio of the item size to the rest capacity, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with lower ratios and higher indexes, and ensure a diverse scoring function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 / ratios * (bins != np.max(bins))) + (5 * np.sqrt(indices)) + (1 / np.log(np.maximum(1 / ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(np.log(item/bins))\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins that have a remaining capacity greater than half of the maximum capacity to encourage the use of larger bins and minimize the number of used bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins > half_capacity) * item\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity divided by the item size, the sine of the index of the bin, and the square root of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (np.sqrt(bins / item) * np.sin(indices)) / np.sqrt(np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with higher ratios and lower indexes, and ensure a diverse scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 * ratios * (bins == np.max(bins))) - (5 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a modified combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a power and weighted differently, to further prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = (1 / ratios)**2 - np.sqrt(np.arange(len(bins)))**3 + np.exp(np.log(ratios))**4\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by calculating the product of the bin's rest capacity divided by the item size, the square of the logarithm of the ratio, and a penalization factor based on the index of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (bins / item) * (np.log(log_ratios + 1) ** 2) - indices\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity, penalize bins with maximum capacity, and prioritize bins with minimum remaining capacity to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n min_capacity = np.min(bins)\\n \\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n scores += (min_capacity - bins)\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin by calculating the product of the bin's rest capacity divided by the item size, the square of the logarithm of the ratio, and a penalization factor based on the index of the bin. This new algorithm uses a different penalization factor based on the index of the bin compared to the original algorithm.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n penalization_factor = np.log(indices + 2) ** 2 # Different penalization factor based on index\\n scores = (bins / item) * (np.log(log_ratios + 1) ** 2) - penalization_factor\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a modified combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a power and weighted differently, to further prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (1 / ratios)**2 - np.sqrt(indices)**3\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (2 * ratios * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by taking the product of the bin's rest capacity divided by the item size, subtracting the index of the bin multiplied by a penalty factor, and adding a decayed logarithmic term based on the ratio of the item size to the rest capacity of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the product of the logarithm of the item size plus 2, the exponential of the negative value of the bin index multiplied by 0.1, and the ratio of the item size to the rest capacity of each bin raised to a power of 3, divided by the rest capacity of each bin.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log10(item + 2) * np.exp(-np.arange(len(bins)) * 0.1) * ((item / bins) ** 3)) / bins\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Calculate the scores for each bin by taking the product of the logarithm of the item size plus 1, the exponential of the negative value of the bin index multiplied by 0.1, and the ratio of the item size to the rest capacity of each bin raised to a power of 2, divided by the rest capacity of each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log10(item + 1) * np.exp(-np.arange(len(bins)) * 0.1) * ((item / bins) ** 2)) / bins\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The modified scoring function takes into account the square root of the rest capacity, subtracted by the item size, and the reciprocal of the logarithm of the proximity to the item size. The scores are then returned as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins - item) - item) / (1 / np.log(item / (1 + np.arange(len(bins)))))\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the sum of the squared differences between the rest capacities of the bins and the item size, multiplied by the logarithm of the ratio of the item size to the rest capacities of the bins and the square of the index of the bin, with each factor being weighted differently, to prioritize bins with smaller differences, higher ratios, and lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = bins - item\\n ratios = np.log(item / bins)\\n scores = (1 * np.power(differences, 2) * ratios) + (0.8 * np.power(indices, 2) * ratios) + (0.6 / np.log(np.maximum(ratios, 1e-8)) * np.power(indices, 2))\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a polynomial function consisting of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (5 * np.power(ratios, 3)) - (4 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the given algorithms calculate scores for each bin based on their capacities and the item size, and adjust those scores based on certain conditions to prioritize certain bins.\\n\\nNew Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity multiplied by the square root of the index of the bin, the reciprocal of the logarithm of the ratio of the item size to the rest capacity, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with lower ratios and higher indexes, and ensure a diverse scoring function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 / ratios * (bins != np.max(bins))) + (5 * np.sqrt(indices)) + (1 / np.log(np.maximum(1 / ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(np.log(item/bins))\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins that have a remaining capacity greater than half of the maximum capacity to encourage the use of larger bins and minimize the number of used bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins > half_capacity) * item\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity divided by the item size, the sine of the index of the bin, and the square root of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (np.sqrt(bins / item) * np.sin(indices)) / np.sqrt(np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with higher ratios and lower indexes, and ensure a diverse scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 * ratios * (bins == np.max(bins))) - (5 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a non-linear combination of the index of the bin, the reciprocal of the logarithm of the ratio, and a constant factor, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (3 * ratios * (bins != np.max(bins))) - (2 * np.power(indices, 0.7)) + (4 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a modified combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a power and weighted differently, to further prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = (1 / ratios)**2 - np.sqrt(np.arange(len(bins)))**3 + np.exp(np.log(ratios))**4\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by calculating the product of the bin's rest capacity divided by the item size, the square of the logarithm of the ratio, and a penalization factor based on the index of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (bins / item) * (np.log(log_ratios + 1) ** 2) - indices\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nMy new algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n ratios = bins / item\\n scores = np.exp(-np.log(ratios) * indices**0.5) * (1 / ratios)**2.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin by calculating the product of the bin's rest capacity divided by the item size, the cube of the natural logarithm of the ratio, and a penalization factor based on the index of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (bins / item) * (np.log(log_ratios + 1) ** 3) - indices\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, the exponential of the logarithm of the ratio, and the cubic root of the bin capacity divided by the item size, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(np.log(item/bins)) - np.cbrt(bins/item)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin by calculating the product of the bin's rest capacity divided by the item size, the square of the logarithm of the ratio, and a penalization factor based on the index of the bin. This new algorithm uses a different penalization factor based on the index of the bin compared to the original algorithm.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n penalization_factor = np.log(indices + 2) ** 2 # Different penalization factor based on index\\n scores = (bins / item) * (np.log(log_ratios + 1) ** 2) - penalization_factor\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a modified combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a power and weighted differently, to further prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (1 / ratios)**2 - np.sqrt(indices)**3\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (2 * ratios * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores. The main difference is that the intermediate score is adjusted by subtracting the item size divided by the maximum capacity from each bin's normalized rest capacity before squaring it.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item/np.max(bins))**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * indices) + (0.5 / np.log(bins - item + 1e-8))\\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a polynomial function consisting of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (5 * np.power(ratios, 3)) - (4 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a polynomial equation involving the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a different power and weighted differently, to prioritize bins with larger ratios, lower indexes, and promote performance in the scoring function. \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (3 * np.power(ratios, 1.5) * np.sqrt(bins)) - (4 * np.power(indices, 0.9)) + (2 / np.log(np.maximum(ratios, 1e-8))) + 10\\n return scores\",\n \"objective\": 0.02425,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(item - bins)\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the given algorithms calculate scores for each bin based on their capacities and the item size, and adjust those scores based on certain conditions to prioritize certain bins.\\n\\nNew Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity multiplied by the square root of the index of the bin, the reciprocal of the logarithm of the ratio of the item size to the rest capacity, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with lower ratios and higher indexes, and ensure a diverse scoring function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 / ratios * (bins != np.max(bins))) + (5 * np.sqrt(indices)) + (1 / np.log(np.maximum(1 / ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(np.log(item/bins))\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins that have a remaining capacity greater than half of the maximum capacity to encourage the use of larger bins and minimize the number of used bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins > half_capacity) * item\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity divided by the item size, the sine of the index of the bin, and the square root of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (np.sqrt(bins / item) * np.sin(indices)) / np.sqrt(np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with higher ratios and lower indexes, and ensure a diverse scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 * ratios * (bins == np.max(bins))) - (5 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a non-linear combination of the index of the bin, the reciprocal of the logarithm of the ratio, and a constant factor, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (3 * ratios * (bins != np.max(bins))) - (2 * np.power(indices, 0.7)) + (4 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a modified combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a power and weighted differently, to further prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n scores = (1 / ratios)**2 - np.sqrt(np.arange(len(bins)))**3 + np.exp(np.log(ratios))**4\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a combination of the index of the bin, the reciprocal of the logarithm of the ratio, and a constant factor, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (2 * ratios * (bins != np.max(bins))) - (np.power(indices, 0.5)) + (3 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign a score to each bin based on various factors such as the ratio of the rest capacity to the item size, the index of the bin, and other penalty factors.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin by calculating the product of the bin's rest capacity divided by the item size, the square of the logarithm of the ratio, and a penalization factor based on the index of the bin.\\n\\nImplementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (bins / item) * (np.log(log_ratios + 1) ** 2) - indices\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nMy new algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n ratios = bins / item\\n scores = np.exp(-np.log(ratios) * indices**0.5) * (1 / ratios)**2.5\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores. The main difference is that the intermediate score is adjusted by subtracting the item size divided by the maximum capacity from each bin's normalized rest capacity before squaring it.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item/np.max(bins))**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the sum of the capacities of consecutively assigned bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n # Additional step: Adjust scores based on the sum of capacities of consecutive bins\\n scores /= np.cumsum(bins)\\n \\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * indices) + (0.5 / np.log(bins - item + 1e-8))\\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 2 * bins - 3 * np.power(indices, 2) + 0.5 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a polynomial function consisting of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (5 * np.power(ratios, 3)) - (4 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a polynomial equation involving the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a different power and weighted differently, to prioritize bins with larger ratios, lower indexes, and promote performance in the scoring function. \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (3 * np.power(ratios, 1.5) * np.sqrt(bins)) - (4 * np.power(indices, 0.9)) + (2 / np.log(np.maximum(ratios, 1e-8))) + 10\\n return scores\",\n \"objective\": 0.02425,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(item - bins)\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the given algorithms calculate scores for each bin based on their capacities and the item size, and adjust those scores based on certain conditions to prioritize certain bins.\\n\\nNew Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the item size to the rest capacity multiplied by the square root of the index of the bin, the reciprocal of the logarithm of the ratio of the item size to the rest capacity, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with lower ratios and higher indexes, and ensure a diverse scoring function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 / ratios * (bins != np.max(bins))) + (5 * np.sqrt(indices)) + (1 / np.log(np.maximum(1 / ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(np.log(item/bins))\\n return scores\",\n \"objective\": 0.03682,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the remaining capacity, with a penalty for bins that have a remaining capacity greater than half of the maximum capacity to encourage the use of larger bins and minimize the number of used bins\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n half_capacity = max_capacity / 2\\n scores = (max_capacity - bins) + (bins > half_capacity) * item\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity divided by the item size, the sine of the index of the bin, and the square root of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (np.sqrt(bins / item) * np.sin(indices)) / np.sqrt(np.log(np.maximum(np.divide(bins, item), 1e-8)))\\n return scores\",\n \"objective\": 0.03773,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the square of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a constant factor, with each factor being weighted differently, to specifically prioritize bins with higher ratios and lower indexes, and ensure a diverse scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 * ratios * (bins == np.max(bins))) - (5 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a power and weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (4 * np.power(ratios, 0.5)) - (2 * np.power(indices, 1.2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + 3\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a non-linear combination of the index of the bin, the reciprocal of the logarithm of the ratio, and a constant factor. The algorithm also incorporates a new factor that takes into account the square root of the ratio, to further prioritize bins with higher ratios and promote better performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n sqrt_ratios = np.sqrt(ratios)\\n indices = np.arange(len(bins))\\n scores = (3 * ratios * (bins != np.max(bins))) - (2 * np.power(indices, 0.7)) + (4 / np.log(np.maximum(ratios, 1e-8))) + (2 * sqrt_ratios) + 5\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a non-linear combination of the index of the bin, the reciprocal of the logarithm of the ratio, and a constant factor, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (3 * ratios * (bins != np.max(bins))) - (2 * np.power(indices, 0.7)) + (4 / np.log(np.maximum(ratios, 1e-8))) + 5\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.sum(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a quadratic function of the index, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8))) + (0.75 * np.power(indices, 2))\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the sum of the capacities of consecutively assigned bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n # Additional step: Adjust scores based on the sum of capacities of consecutive bins\\n scores /= np.cumsum(bins)\\n \\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * indices) + (0.5 / np.log(bins - item + 1e-8))\\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 2 * bins - 3 * np.power(indices, 2) + 0.5 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a polynomial function consisting of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (5 * np.power(ratios, 3)) - (4 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a polynomial equation involving the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a different power and weighted differently, to prioritize bins with larger ratios, lower indexes, and promote performance in the scoring function. \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (3 * np.power(ratios, 1.5) * np.sqrt(bins)) - (4 * np.power(indices, 0.9)) + (2 / np.log(np.maximum(ratios, 1e-8))) + 10\\n return scores\",\n \"objective\": 0.02425,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, multiplied by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and promote better performance in the scoring function. The algorithm aims to minimize the number of used bins by assigning higher scores to bins with larger ratios of rest capacity to item size, prioritizing bins that can accommodate larger items.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 2.5)\\n scores = (10 * ratios * (bins != np.max(bins))) - (3 * np.power(indices, 1.5)) + (1 / np.log(np.maximum(ratios, 1e-8))) + (4 * np.power(ratios, 2)) + 5\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a different power and weighted differently, to prioritize bins with larger ratios, higher indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (np.power(ratios, 2) * (5 * np.sqrt(bins))) + (4 * np.power(indices, 1.1)) + (2 / np.log(np.maximum(ratios, 1e-8))) + 8\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms calculate scores for assigning an item to a bin based on the comparison between the rest capacity of the bin and the size of the item. They also incorporate factors like normalization, logarithms, indices, and differences between consecutive elements to adjust and update the scores.\\n\\nNew Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, multiplied by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and promote better performance in the scoring function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 1.5)\\n scores = (4 * ratios * (bins != np.max(bins))) - (2 * np.power(indices, 1.2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + (2 * np.power(ratios, 2)) + 3\\n return scores\",\n \"objective\": 0.02717,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, while incorporating a non-linear function of these factors with different weights, to prioritize bins with higher ratios, lower indexes, and promote diversity in the scoring function.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (2 * np.power(ratios, 3)) - (3 * np.power(indices, 2)) + (1.5 / log_ratios) - (0.5 * np.sqrt(indices))\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a polynomial equation involving the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a different power and weighted differently, to prioritize bins with larger ratios, lower indexes, and promote performance in the scoring function. \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (np.sqrt(ratios) * np.sqrt(bins)) - (2 * np.power(indices, 0.45)) + (1 / np.log(np.maximum(ratios, 1e-8))) + 10\\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, multiplied by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and promote better performance in the scoring function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 1.5)\\n scores = (6 * ratios * (bins != np.max(bins))) - (3 * np.power(indices, 1.5)) + (1 / np.log(np.maximum(ratios, 1e-8))) + (2 * np.power(ratios, 2)) + 5\\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone: The common backbone idea in the provided algorithms is to assign a score to each bin based on a combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on a non-linear combination of the inverse of the ratio of the rest capacity to the item size, the square root of the index of the bin, and the exponential of the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with smaller capacities, lower indexes, and encourage diversity in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (item / bins)) - np.sqrt(np.arange(len(bins))) + np.exp(item - bins)\\n return scores\",\n \"objective\": 0.03371,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scale_factor = 1.0 / max_bin_cap\\n scores = (bins - max_bin_cap) ** 2 * scale_factor\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first determines the maximum capacity of the bins and computes a score for each bin based on a modified formula using the item and the bin capacities. It then adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and returns the resulting scores.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap) ** 2 / item\\n scores = np.where(bins > item, -scores, scores) * np.log1p(bins)\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.max(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin by first normalizing the rest capacities of feasible bins, then computes an intermediate score for each bin by comparing its capacity with the item size, adjusts the scores based on the maximum capacity, updates the scores based on the differences between consecutive elements, and finally returns the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n norm_bins = bins / np.sum(bins)\\n scores = np.zeros_like(bins, dtype=float)\\n scores += (norm_bins - item)**2 + item**2 / (norm_bins**2)\\n scores += norm_bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a combination of the absolute difference between the rest capacity and the item size, the square root of the index of the bin, and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with smaller differences, higher indices, and promote diversity in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n differences = np.abs(bins - item)\\n scores = (1 / differences) + np.sqrt(indices) - (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by the sine of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.sin(indices) + 1 / np.log(np.maximum(bins / item, 1e-8)) - 2 * indices\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms assign scores to bins based on the ratio of rest capacity to item size, and use different combinations of factors and functions to prioritize bins with larger ratios and promote better performance in the scoring function.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the product of the rest capacity and the square root of the item size, subtracted by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the cube of the ratio to further prioritize bins with higher ratios and minimize the number of used bins.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 2.2)\\n scores = (bins * np.sqrt(item) - 3 * np.power(indices, 1.4) + (1 / np.log(np.maximum(ratios, 1e-8)))) - (6 * np.power(ratios, 3))\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin, the reciprocal of the logarithm of the ratio of the rest capacity to the item size, and a quadratic function of the index, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8))) + (0.75 * np.power(indices, 2))\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by determining the maximum capacity of the bins, computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main difference is that this algorithm includes an additional step of adjusting the scores based on the sum of the capacities of consecutively assigned bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n # Additional step: Adjust scores based on the sum of capacities of consecutive bins\\n scores /= np.cumsum(bins)\\n \\n return scores\",\n \"objective\": 0.01811,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins * (bins == np.max(bins))) - (3 * np.power(indices, 2)) + (0.5 / np.log(np.maximum(bins / item, 1e-8)))\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = (2 * bins) - (3 * indices) + (0.5 / np.log(bins - item + 1e-8))\\n return scores\",\n \"objective\": 0.02002,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin based on the ratio of the rest capacity to the item size multiplied by the cosine of the index of the bin and the square root of the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = bins * np.cos(indices) + 1 / np.sqrt(np.log(np.maximum(bins / item, 1e-8))) - 3 * indices\\n return scores\",\n \"objective\": 0.02032,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to assign a score to each bin based on some combination of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio.\\n\\nNew algorithm description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size multiplied by a power of the index of the bin and the reciprocal of the logarithm of the ratio of the rest capacity to the item size, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n scores = 2 * bins - 3 * np.power(indices, 2) + 0.5 / np.log(np.maximum(bins / item, 1e-8))\\n return scores\",\n \"objective\": 0.02053,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns a score to each bin based on a polynomial function consisting of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n scores = (5 * np.power(ratios, 3)) - (4 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8)))\\n return scores\",\n \"objective\": 0.02093,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a modified polynomial function consisting of the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being weighted differently, to prioritize bins with higher ratios, lower indexes, and promote performance in the scoring function. The modified polynomial function introduces an additional term that takes into account the difference between the rest capacity and the item size, aiming to fill bins as much as possible without exceeding their capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n log_ratios = np.log(ratios)\\n indices = np.arange(len(bins))\\n differences = bins - item\\n scores = (5 * np.power(ratios, 3)) - (4 * np.power(indices, 2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + (1 / np.power(differences, 2))\\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, multiplied by a non-linear combination of the index of the bin, a different power of the ratio, and a different constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and promote better performance in the scoring function. The algorithm aims to minimize the number of used bins by assigning higher scores to bins with larger ratios of rest capacity to item size, prioritizing bins that can accommodate larger items.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n scores = (7 * ratios * (bins != np.max(bins))) - (2 * np.power(indices, 1.2)) + (1 / np.log(np.maximum(ratios, 1e-8))) + (6 * np.power(ratios, 2)) + 10\\n return scores\",\n \"objective\": 0.02264,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on a polynomial equation involving the ratio of the rest capacity to the item size, the index of the bin, and the logarithm of the ratio, with each factor being raised to a different power and weighted differently, to prioritize bins with larger ratios, lower indexes, and promote performance in the scoring function. \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n log_ratios = np.log(bins / item + 1e-8)\\n sqrt_bins = np.sqrt(bins)\\n pow_indices = np.power(np.arange(len(bins)), 0.9)\\n scores = 3 * np.power(bins / item, 1.5) * sqrt_bins - 4 * pow_indices + 2 / log_ratios + 10\\n return scores\",\n \"objective\": 0.02425,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns a score to each bin based on the ratio of the rest capacity to the item size, multiplied by a non-linear combination of the index of the bin, a power of the ratio, and a constant factor, with an additional factor involving the square of the ratio to further prioritize bins with higher ratios and promote better performance in the scoring function. The algorithm aims to minimize the number of used bins by assigning higher scores to bins with larger ratios of rest capacity to item size, prioritizing bins that can accommodate larger items.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n power_ratios = np.power(ratios, 2.5)\\n scores = (10 * ratios * (bins != np.max(bins))) - (3 * np.power(indices, 1.5)) + (1 / np.log(np.maximum(ratios, 1e-8))) + (4 * np.power(ratios, 2)) + 5\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_bins = bins / max_capacity\\n normalized_item = item / max_capacity\\n \\n scores = (1 - normalized_bins) - np.abs(normalized_bins - normalized_item) + (normalized_bins == 1) * normalized_item + (normalized_bins >= normalized_item) * normalized_item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - np.abs(bins - item) + (bins == max_capacity) * item + (bins >= item) * item\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity and their index position in the list, with additional penalization terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins. The algorithm also incorporates a logarithmic factor to further differentiate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) * np.log10(np.arange(bins.size)+1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to prioritize bins that have a capacity close to the size of the item, while also penalizing bins that are close to maximum capacity, in order to minimize the number of used bins:\\n\\nAlgorithm description: The algorithm calculates the score for each bin based on the remaining capacity, with a larger penalty for bins that are close to maximum capacity, and a larger reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - 2 * np.abs(bins - item) + 2 * (bins == max_capacity) * item + (bins >= item) * item\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the rest capacities, the ratio of the rest capacity to the maximum bin capacity, and a factor that penalizes bins with large rest capacities, and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item) / np.maximum(bins, item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for each bin based on their remaining capacities and some specific conditions or calculations.\\n\\nNew algorithm description: The algorithm calculates the scores for each bin based on the inverse of the rest capacity, the logarithm of the bin number, and a penalty for bins with maximum capacity, returning a Numpy array of scores for assignment.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacities = 1 / bins\\n log_bin_numbers = np.log(np.arange(1, num_bins + 1))\\n penalty = (bins == np.max(bins)) * item\\n scores = capacities + log_bin_numbers - penalty\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on their remaining capacity.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on their remaining capacity and prioritize bins with lower remaining capacity, while also discouraging the use of bins with maximum capacity, in order to minimize the number of used bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item - (bins == bins.max()) * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for each bin based on their remaining capacities and some specific conditions or calculations.\\n\\nNew algorithm description: The algorithm calculates the scores for each bin based on the inverse of the rest capacity, the logarithm of the bin number, and a penalty for bins with maximum capacity, returning a Numpy array of scores for assignment.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacities = 1 / bins / np.max(bins)\\n log_bin_numbers = np.log(np.arange(1, num_bins + 1)) / np.log(num_bins)\\n penalty = (bins == np.max(bins)) * item\\n scores = capacities + log_bin_numbers - penalty\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on their remaining capacity. \\n\\nNew algorithm: The score function calculates the scores for each bin based on their remaining capacity, with additional penalty terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to multiple bins to minimize the number of used bins, considering the rest capacities of the bins. The algorithm calculates the scores for each bin based on their rest capacities and assigns a portion of the item to each bin with a proportional score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum(bins, 1)\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the inverse of the rest capacity, the square root of the bin number, and a penalty for bins with maximum capacity, returning a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacities = 1 / bins\\n sqrt_bin_numbers = np.sqrt(np.arange(1, num_bins + 1))\\n penalty = (bins == np.max(bins)) * item\\n scores = capacities + sqrt_bin_numbers - penalty\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the rest capacities, the ratio of the rest capacity to the maximum bin capacity, and a factor that penalizes bins with large rest capacities, and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / np.maximum((bins - item), 1)) * ((bins / max_capacity) ** 2) * np.exp(-bins / max_capacity)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins. However, in this new algorithm, the score for each bin is also influenced by the ratio of the rest capacity of that bin to the maximum bin capacity, in addition to the previous algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = bins / np.maximum((bins - item), 1) * (bins / max_capacity)\\n scores[bins == max_capacity] = 0\\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the scores for each bin based on a combination of the rest capacity, the index, and a penalty for bins with low capacities, returning a Numpy array of scores for assignment. \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacities = bins / (1 + np.arange(num_bins))\\n penalty = (bins < (0.1 * item)) * (0.5 * item)\\n scores = capacities - penalty - np.arange(num_bins) * 0.01\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacities and the ratio of the logarithm of the item size to the available capacity, where the item is penalized if it cannot fit completely into a bin. The algorithm also penalizes bins with the maximum capacity by setting their score to a negative value, ensuring they are not used if there are other bins available.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n remaining_capacity = bins - item # Calculate remaining capacity of each bin after assigning the item\\n \\n # Calculate scores based on the ratio of logarithm of item size to available capacity\\n mask = remaining_capacity > 0\\n scores[mask] = np.log(item) / remaining_capacity[mask]\\n \\n # Penalize bins with maximum capacity by setting their score to a negative value\\n scores[bins == bins.max()] = -1\\n \\n return scores\",\n \"objective\": 0.04487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on their remaining capacity, taking into account a penalty for bins with low capacities and a reward for bins with maximum capacity, in order to optimize the assignment and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacities = bins / (1 + np.arange(num_bins))\\n penalty = (bins < (0.1 * item)) * (0.5 * item)\\n reward = (bins == np.max(bins)) * (0.2 * item)\\n scores = capacities - penalty + reward - np.arange(num_bins) * 0.01\\n return scores\",\n \"objective\": 0.04598,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their rest capacities and the ratio of the item size to the available capacity, where the item is penalized if it cannot fit completely into a bin. The algorithm also penalizes bins with the maximum capacity by setting their score to zero, ensuring they are not used if there are other bins available.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n remaining_capacity = bins - item # Calculate remaining capacity of each bin after assigning the item\\n \\n # Calculate scores based on the ratio of item size to available capacity\\n mask = remaining_capacity > 0\\n scores[mask] = item / remaining_capacity[mask]\\n \\n # Penalize bins with maximum capacity by setting their score to zero\\n scores[bins == bins.max()] = 0\\n \\n return scores\",\n \"objective\": 0.04719,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, and a factor that biases the scores towards bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n # Compute the scores for each bin\\n scores = np.exp(-np.abs(bins - item) ** 2) * np.log(bins) ** 2 + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins) / item) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with lower remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, power, and absolute value functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(bins - item) + 1/(np.log(bins - item + 1) + 1)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on its remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, various mathematical functions, and penalty terms and reward terms.\\n\\nMy new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the logarithm of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.log(bins + 1) / item) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2)\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on their remaining capacity, the difference between the item size and bin capacities, and the position of the bin in the list.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the bin's remaining capacity, the square root of the absolute difference between the item size and the bin capacities, and a combination of penalty and reward terms that consider the logarithmic factor, the square root of the capacity, and the inverse difference factor, using a combination of exponential, logarithmic, power, and square root functions along with penalty terms and reward terms to create a complex and effective scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log((max_capacity - bins + 1)**2) + np.sqrt(bins) + (np.log(1/(np.abs(bins - item) + 1)))**2 + np.abs(np.arange(num_bins) - middle_index) + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3)\\n\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to bins based on their remaining capacity, the difference between the bin's capacity and the item size, and various mathematical functions and penalty terms.\\n\\nMy new algorithm assigns scores to bins based on the ratio of their remaining capacity to the item size, the logarithmic factor, the inverse of the absolute difference between the bin's capacity and the item size, a penalty term that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the capacity, resulting in a highly intricate scoring system.\\n\\nHere is the implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(bins)\\n\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on their remaining capacity, the difference between the item size and bin capacities, and the position of the bin in the list. \\n\\nNew algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, the square root of the absolute difference between the item size and the bin capacities, the logarithmic factor, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and absolute value functions along with penalty terms and the square root factor to create a complex and effective scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(bins + 1) + np.sqrt(np.abs(bins - item)) + np.log(np.abs(bins - item) + 1) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor to create a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * bins / item) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the index position, and various mathematical functions to create a complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) +\\n np.log(max_capacity - bins + 2) * np.sin(np.pi * bins / item) +\\n np.sqrt(bins + 1) +\\n np.log(bins + 2) +\\n np.abs(np.arange(bins.size) - bins.size // 2) +\\n 1/(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the inverse logarithmic difference factor to create a complex and effective scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(np.sqrt(bins + 1)) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the square root factor, the bin's position in the list, the absolute difference between the bin's capacity and the item size, and the maximum capacity of the bins, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\\n\\nHere is the Python implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.sqrt(max_capacity - bins + 1) + np.log(bins + 1) + np.log(max_capacity - bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, and a factor that biases the scores towards bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n # Compute the scores for each bin\\n scores = np.exp(-np.abs(bins - item) ** 2) * np.log(bins) ** 2 + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins) / item) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with lower remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, the item size, the logarithmic factor, and a combination of penalty and reward terms that consider the absolute difference between the bin's capacity and the item size, the bin's position in the list, and a trigonometric term, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs((np.log(bins) - np.log(item))**2 + np.sin(np.pi * bins / item))) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the reciprocal of the capacity, creating a complex and effective scoring system.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi / bins) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the logarithmic factor, the square root of the capacity, and a sinusoidal function applied to the square root of the capacity, using penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins + 1)) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities, taking into account another penalizing factor based on the square root of the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2) - np.sqrt(bins)\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2)\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the item size, the logarithmic factor, and a combination of penalty and reward terms that consider the absolute difference between the bin's capacity and the item size, the bin's position in the list, a trigonometric term, and the square root of the capacity, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the square root factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(bins) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on their remaining capacity, the difference between the item size and bin capacities, and the position of the bin in the list.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the bin's remaining capacity, the square root of the absolute difference between the item size and the bin capacities, and a combination of penalty and reward terms that consider the logarithmic factor, the square root of the capacity, and the inverse difference factor, using a combination of exponential, logarithmic, power, and square root functions along with penalty terms and reward terms to create a complex and effective scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log((max_capacity - bins + 1)**2) + np.sqrt(bins) + (np.log(1/(np.abs(bins - item) + 1)))**2 + np.abs(np.arange(num_bins) - middle_index) + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity, the item size, and a combination of penalty and reward terms that consider the ratio of the remaining capacity to the item size, the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the reciprocal of the capacity, creating a complex and effective scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = (bins / item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi / bins) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins) / item) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, the item size, the logarithmic factor, and a combination of penalty and reward terms that consider the absolute difference between the bin's capacity and the item size, the bin's position in the list, and a trigonometric term, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs((np.log(bins) - np.log(item))**2 + np.sin(np.pi * bins / item))) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the logarithmic factor, the square root of the capacity, and a sinusoidal function applied to the square root of the capacity, using penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins + 1)) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities, taking into account another penalizing factor based on the square root of the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2) - np.sqrt(bins)\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2)\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, and a factor that biases the scores towards bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n # Compute the scores for each bin\\n scores = np.exp(-np.abs(bins - item) ** 2) * np.log(bins) ** 2 - np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on their remaining capacity, the difference between the item size and bin capacities, and the position of the bin in the list.\\n\\nNew algorithm description: The new algorithm assigns scores to bins based on the bin's remaining capacity, the square root of the absolute difference between the item size and the bin capacities, and a combination of penalty and reward terms that consider the logarithmic factor, the square root of the capacity, and the inverse difference factor, using a combination of exponential, logarithmic, power, and square root functions along with penalty terms and reward terms to create a complex and effective scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log((max_capacity - bins + 1)**2) + np.sqrt(bins) + (np.log(1/(np.abs(bins - item) + 1)))**2 + np.abs(np.arange(num_bins) - middle_index) + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, the item size, the logarithmic factor, and a combination of penalty and reward terms that consider the absolute difference between the bin's capacity and the item size, the bin's position in the list, and a trigonometric term, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs((np.log(bins) - np.log(item))**2 + np.sin(np.pi * bins / item))) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the logarithmic factor, the square root of the capacity, and a sinusoidal function applied to the square root of the capacity, using penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins + 1)) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities, taking into account another penalizing factor based on the square root of the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2) - np.sqrt(bins)\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2)\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, and a factor that biases the scores towards bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n # Compute the scores for each bin\\n scores = np.exp(-np.abs(bins - item) ** 2) * np.log(bins) ** 2 - np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, the item size, the logarithmic factor, the square of the difference between the bin capacity and the item size, a combination of penalty and reward terms that consider the absolute difference between the bin's capacity and the item size, the bin's position in the list, a trigonometric term, and the inverse of the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs((np.log(bins)**2 - np.log(item)**2)**2 + np.sin(np.pi * bins / item)**2)) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3 + np.cos(np.pi * bins / item) + (1/(np.abs(bins - item) + 1))\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, the item size, the logarithmic factor, and a combination of penalty and reward terms that consider the absolute difference between the bin's capacity and the item size, the bin's position in the list, and a trigonometric term, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs((np.log(bins) - np.log(item))**2 + np.sin(np.pi * bins / item))) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the logarithmic factor, the square root of the capacity, and a sinusoidal function applied to the square root of the capacity, using penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins + 1)) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities, taking into account another penalizing factor based on the square root of the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2) - np.sqrt(bins)\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2)\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, and a factor that biases the scores towards bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n # Compute the scores for each bin\\n scores = np.exp(-np.abs(bins - item) ** 2) * np.log(bins) ** 2 - np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (2 * (bins - avg_bin_cap)**2 / item) + 3 * (bins**2 / (item**2))\\n scores += 4 * (bins**2 / item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This novel algorithm calculates scores for bins based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the position of the bin in the list, and the sum of the bin capacities divided by the item size, using a combination of exponential, logarithmic, and trigonometric functions along with penalty terms, reward terms, and the average capacity factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) + np.abs(np.arange(num_bins) - middle_index) + np.cos(np.pi * bins / item) + (np.log(bins + 1))**2 + (bins == item) * item**3 + np.exp(-np.abs(np.sum(bins) / item))\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the position of the bin in the list, and other factors such as logarithmic, trigonometric, and exponential functions.\\n\\nNew algorithm description: This novel algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-(np.abs(bins) - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.abs(np.sin(np.pi * bins / item)) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the logarithmic factor, the square root of the capacity, and a sinusoidal function applied to the square root of the capacity, using penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins + 1)) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities, taking into account another penalizing factor based on the square root of the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2) - np.sqrt(bins)\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2)\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (2 * (bins - avg_bin_cap)**2 / item) + 3 * (bins**2 / (item**2))\\n scores += 4 * (bins**2 / item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = bins.size // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(bins.size) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This novel algorithm calculates scores for bins based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the position of the bin in the list, and the sum of the bin capacities divided by the item size, using a combination of exponential, logarithmic, and trigonometric functions along with penalty terms, reward terms, and the average capacity factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n avg_capacity = np.mean(bins)\\n \\n scores = np.exp(-np.abs(bins - item)) + np.abs(np.arange(num_bins) - (num_bins // 2)) + np.cos(np.pi * bins / item) + (np.log(bins + 1))**2 + (bins == item) * item**3 + np.exp(-np.abs(np.sum(bins) / item))\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, the logarithmic factor, and the square root of the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, the inverse difference factor, and the square root factor to create a complex and effective scoring system.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3 + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities, but with a different parameter settings.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on their remaining capacity, index position, remaining capacity bias factor, and penalty term using a combination of exponential, logarithmic, and power functions, along with the square root of the absolute difference between the item size and the bin capacities. The parameters used are different from the original algorithm.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 3)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3)\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms assign scores to bins based on various factors such as remaining capacity, position in the list, absolute difference between bin capacity and item size, exponential, logarithmic, power, trigonometric, and square root functions.\\n\\nNew Algorithm Description: This new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item)) - np.log(bins + 1)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the logarithmic factor, the square root of the capacity, and a sinusoidal function applied to the square root of the capacity, using penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * np.sqrt(bins + 1)) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities, taking into account another penalizing factor based on the square root of the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2) - np.sqrt(bins)\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on their remaining capacity, the index position of the bin, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, power, and trigonometric functions along with the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3) + np.sin(np.abs(item - bins)*2)\\n\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on a modified formula, involving the bins and the item, and then computes a weight for each bin based on its score and the score of the previous bin, adjusting the weights based on the difference in scores between consecutive bins, and finally returning the resulting weights as scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * (bins - np.average(bins))**2 / item) + 3 * (bins**2 / (item**2))\\n scores += 4 * (bins**2 / item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = bins.size // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(bins.size) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: This algorithm calculates a score for a given item based on its comparison with a list of bins using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between the bins, and finally returning the resulting scores. \\n\\nSteps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores using the formula: (bins - max_bin_cap)**2 / (item**2) + bins**2 / (max_bin_cap**3) + bins**2 / (max_bin_cap**4).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between the bins using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n``` Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (max_bin_cap**3) + bins**2 / (max_bin_cap**4)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.mean(bins) # Replaced np.median() with np.mean()\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of factors such as the difference in capacity compared to the item size, the bin's position in the list, and various functions applied to the differences.\\n\\nNew algorithm description:\\nThe new algorithm assigns scores to bins based on the ratio between the remaining capacity of each bin and the item size, the logarithmic factor, and the square root of the absolute difference between the capacity and the item size, combined with penalty and reward terms to create a complex and effective scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.log(bins / item) + np.sqrt(np.abs(bins - item)) + np.abs(np.arange(len(bins)) - middle_index) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, the logarithmic factor, and the square root of the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, the inverse difference factor, and the square root factor to create a complex and effective scoring system.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3 + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities, but with a different parameter settings.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on their remaining capacity, index position, remaining capacity bias factor, and penalty term using a combination of exponential, logarithmic, and power functions, along with the square root of the absolute difference between the item size and the bin capacities. The parameters used are different from the original algorithm.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 3)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3)\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms assign scores to bins based on various factors such as remaining capacity, position in the list, absolute difference between bin capacity and item size, exponential, logarithmic, power, trigonometric, and square root functions.\\n\\nNew Algorithm Description: This new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item)) - np.log(bins + 1)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings):\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores. However, in this new algorithm, we will modify the formula used to compute the scores to improve performance. The main steps include:\\n\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: ((bins - max_bin_cap)**2 / item) + ((bins**2 - max_bin_cap**2) / item**2) + ((bins**2 - max_bin_cap**3) / item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = ((bins - max_bin_cap)**2 / item) + ((bins**2 - max_bin_cap**2) / item**2) + ((bins**2 - max_bin_cap**3) / item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a combination of the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a reward term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n middle_index = (num_bins - 1) // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New Algorithm Description:\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the mean capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements and the logarithm of bin capacities, and finally returning the resulting scores.\\n\\nNew Algorithm Steps:\\n1. Determine the mean capacity of the bins by taking the average value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - mean_bin_cap)**2 / item + bins**2 / (mean_bin_cap**2 * np.log(bins)) + bins**2 / (item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mean_bin_cap = np.mean(bins)\\n scores = (bins - mean_bin_cap)**2 / item + bins**2 / (mean_bin_cap**2 * np.log(bins)) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00553,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings):\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores. However, in this new algorithm, we will modify the formula used to compute the scores to improve performance. The main steps include:\\n\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: ((bins - max_bin_cap)**2 / item) + ((bins**2 - max_bin_cap**2) / item**2) + ((bins**2 - max_bin_cap**3) / item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_caps = bins - np.max(bins)\\n scores = (bin_caps ** 2 / item) + ((bins ** 2 - bin_caps ** 2) / item ** 2) + ((bins ** 2 - bin_caps ** 3) / item ** 3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on a modified formula, involving the bins and the item, and then computes a weight for each bin based on its score and the score of the previous bin, adjusting the weights based on the difference in scores between consecutive bins, and finally returning the resulting weights as scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * (bins - np.average(bins))**2 / item) + 3 * (bins**2 / (item**2))\\n scores += 4 * (bins**2 / item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = bins.size // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(bins.size) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula that prioritizes bins closer in size to the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nMain steps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + 1000*(max_bin_cap - bins)**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / item**2 + 1000*(max_bin_cap - bins)**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.mean(bins) # Replaced np.median() with np.mean()\\n scores = (bins - central_tendency)**2 + bins**2 / (central_tendency**2) + bins**2 / central_tendency**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of factors such as the difference in capacity compared to the item size, the bin's position in the list, and various functions applied to the differences.\\n\\nNew algorithm description:\\nThe new algorithm assigns scores to bins based on the ratio between the remaining capacity of each bin and the item size, the logarithmic factor, and the square root of the absolute difference between the capacity and the item size, combined with penalty and reward terms to create a complex and effective scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.log(bins / item) + np.sqrt(np.abs(bins - item)) + np.abs(np.arange(len(bins)) - middle_index) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities, but with a different parameter settings.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on their remaining capacity, index position, remaining capacity bias factor, and penalty term using a combination of exponential, logarithmic, and power functions, along with the square root of the absolute difference between the item size and the bin capacities. The parameters used are different from the original algorithm.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 3)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3)\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms assign scores to bins based on various factors such as remaining capacity, position in the list, absolute difference between bin capacity and item size, exponential, logarithmic, power, trigonometric, and square root functions.\\n\\nNew Algorithm Description: This new algorithm assigns scores to bins based on the bin's remaining capacity, the cube of the absolute difference between the item size and the bin capacities, the logarithmic factor, the bin's position in the list, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item)) - np.log(bins + 1)\\n \\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"New Algorithm Description:\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the mean capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements and the logarithm of bin capacities, and finally returning the resulting scores.\\n\\nNew Algorithm Steps:\\n1. Determine the mean capacity of the bins by taking the average value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - mean_bin_cap)**2 / item + bins**2 / (mean_bin_cap**2 * np.log(bins)) + bins**2 / (item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mean_bin_cap = np.mean(bins)\\n scores = (bins - mean_bin_cap)**2 / item + bins**2 / (mean_bin_cap**2 * np.log(bins)) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00553,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nMain Steps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using a modified formula: (max_bin_cap - bins)**2 / (max_bin_cap - item) + bins**2 / (item**2) + bins**2 / (item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (max_bin_cap - bins)**2 / (max_bin_cap - item) + bins**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings):\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores. However, in this new algorithm, we will modify the formula used to compute the scores to improve performance. The main steps include:\\n\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: ((bins - max_bin_cap)**2 / item) + ((bins**2 - max_bin_cap**2) / item**2) + ((bins**2 - max_bin_cap**3) / item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_caps = bins - np.max(bins)\\n scores = (bin_caps ** 2 / item) - (bins / item) + (bins ** 3 / item ** 3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on a modified formula, involving the bins and the item, and then computes a weight for each bin based on its score and the score of the previous bin, adjusting the weights based on the difference in scores between consecutive bins, and finally returning the resulting weights as scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * (bins - np.average(bins))**2 / item) + 3 * (bins**2 / (item**2))\\n scores += 4 * (bins**2 / item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = bins.size // 2\\n \\n scores = np.cos(np.pi * bins / item) + np.abs(np.arange(bins.size) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula that prioritizes bins closer in size to the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nMain steps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + 1000*(max_bin_cap - bins)**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / item**2 + 1000*(max_bin_cap - bins)**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities, but with a different parameter settings.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on their remaining capacity, index position, remaining capacity bias factor, and penalty term using a combination of exponential, logarithmic, and power functions, along with the square root of the absolute difference between the item size and the bin capacities. The parameters used are different from the original algorithm.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.abs(bins - item) + np.abs(np.arange(num_bins) - middle_index)\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.mean(bins)\\n scores = (bins - central_tendency)**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of factors such as the difference in capacity compared to the item size, the bin's position in the list, and various functions applied to the differences.\\n\\nNew algorithm description:\\nThe new algorithm assigns scores to bins based on the ratio between the remaining capacity of each bin and the item size, the logarithmic factor, and the square root of the absolute difference between the capacity and the item size, combined with penalty and reward terms to create a complex and effective scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.log(bins / item) + np.sqrt(np.abs(bins - item)) + np.abs(np.arange(len(bins)) - middle_index) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities, but with a different parameter settings.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on their remaining capacity, index position, remaining capacity bias factor, and penalty term using a combination of exponential, logarithmic, and power functions, along with the square root of the absolute difference between the item size and the bin capacities. The parameters used are different from the original algorithm.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 3)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3)\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for the bins based on various factors such as the remaining capacity of the bins, the index position of the bins, and penalty/reward terms. These scores are then adjusted based on the difference between consecutive bins.\\n\\nMy new algorithm assigns scores to bins based on the remaining capacity of the bins, the index position of the bins, a penalty term that encourages using bins with higher remaining capacity, and a reward term that promotes using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) + np.sin(np.pi * bins / item)\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign higher scores to bins that have a remaining capacity close to the size of the item, while penalizing bins that are closer to maximum capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and absolute value functions to calculate the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.exp(-(np.abs(bins - item))) * np.log(max_capacity - bins) + np.sqrt(bins) + np.log(max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Modified score function\\n\\nThe algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a stronger reward for bins that have a capacity close to half the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - np.abs(bins - item) + (bins == max_capacity) * item + (bins == item) * item**2 + np.abs(bins - item * 0.5)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n normalized_bins = bins / max_capacity\\n normalized_item = item / max_capacity\\n \\n scores = (1 - normalized_bins) - np.abs(normalized_bins - normalized_item) + (normalized_bins == 1) * normalized_item + (normalized_bins >= normalized_item) * normalized_item\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins) - np.abs(bins - item) + (bins == np.max(bins)) * item + (bins >= item) * item\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a stronger reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) - np.abs(bins - item) + (np.max(bins) == bins) * item + (bins == item) * item**2\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity and their index position in the list, with additional penalization terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins. The algorithm also incorporates a logarithmic factor to further differentiate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) * np.log10(np.arange(bins.size)+1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to prioritize bins that have a capacity close to the size of the item, while also penalizing bins that are close to maximum capacity, in order to minimize the number of used bins:\\n\\nAlgorithm description: The algorithm calculates the score for each bin based on the remaining capacity, with a larger penalty for bins that are close to maximum capacity, and a larger reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - 2 * np.abs(bins - item) + 2 * (bins == max_capacity) * item + (bins >= item) * item\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity, with a stronger penalty for bins that are close to maximum capacity, and a reward for bins that have a capacity close to half the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**2 - np.abs(bins - item) + (bins == max_capacity) * item**2 + (bins == item) * item**3 - np.abs(bins - item * 0.5)**2\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to multiple bins to minimize the number of used bins, considering the rest capacities of the bins. The algorithm calculates the scores for each bin based on their rest capacities and assigns a portion of the item to each bin with a proportional score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for each bin based on their remaining capacities and some specific conditions or calculations.\\n\\nNew algorithm description: The algorithm calculates the scores for each bin based on the inverse of the rest capacity, the logarithm of the bin number, and a penalty for bins with maximum capacity, returning a Numpy array of scores for assignment.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacities = 1 / bins\\n log_bin_numbers = np.log(np.arange(1, num_bins + 1))\\n penalty = (bins == np.max(bins)) * item\\n scores = capacities + log_bin_numbers - penalty\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, and a penalization factor that encourages using bins with lower remaining capacity and discourages using bins with maximum capacity. It also incorporates a logarithmic factor to further differentiate scores and a square root factor to emphasize smaller remaining capacity bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) * np.log10(np.arange(bins.size)+1) - np.sqrt(bins)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, penalizing maximum capacity bins and adjusting scores based on their index position in the list. It incorporates a cubic factor, a square root factor, and a logarithmic factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**3 - np.abs(bins - item)**2 + (bins == max_capacity) * (item**3) + np.sqrt(bins) - np.log(np.arange(bins.size)+1)\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, and a penalization factor that encourages using bins with lower remaining capacity and discourages using bins with maximum capacity. It also incorporates a logarithmic factor to further differentiate scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) + np.log(bins)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bins based on their rest capacities, prioritizing bins with lower rest capacities and assigning a portion of the item proportional to the difference between the capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = 1 / np.maximum(rest_capacities, 1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity and their index position in the list, with additional penalization terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins. The algorithm also incorporates a logarithmic factor to further differentiate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the end of the list.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n end_index = bins.size - 1\\n max_capacity = bins.max()\\n scores = (max_capacity - bins) + (item - np.arange(bins.size)) + np.log(bins) + np.abs(end_index - np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, with additional penalty terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins. The algorithm also incorporates a linear factor to differentiate scores.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * np.max(bins) - bins) + (bins == np.max(bins)) * item - np.arange(len(bins)) + np.log10(np.arange(len(bins))+1)\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on their remaining capacity. \\n\\nNew algorithm: The score function calculates the scores for each bin based on their remaining capacity, with additional penalty terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"New Algorithm Description:\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the mean capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements and the logarithm of bin capacities, and finally returning the resulting scores.\\n\\nNew Algorithm Steps:\\n1. Determine the mean capacity of the bins by taking the average value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - mean_bin_cap)**2 / item + bins**2 / (mean_bin_cap**2 * np.log(bins)) + bins**2 / (item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n mean_bin_cap = np.mean(bins)\\n scores = (bins - mean_bin_cap)**2 / item + bins**2 / (mean_bin_cap**2 * np.log(bins)) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00553,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nMain Steps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using a modified formula: (max_bin_cap - bins)**2 / (max_bin_cap - item) + bins**2 / (item**2) + bins**2 / (item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nImplementation in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (max_bin_cap - bins)**2 / (max_bin_cap - item) + bins**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings):\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores. However, in this new algorithm, we will modify the formula used to compute the scores to improve performance. The main steps include:\\n\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: ((bins - max_bin_cap)**2 / item) + ((bins**2 - max_bin_cap**2) / item**2) + ((bins**2 - max_bin_cap**3) / item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_caps = bins - np.max(bins)\\n scores = (bin_caps ** 2 / item) - (bins / item) + (bins ** 3 / item ** 3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the following steps: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array. \\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + np.exp(bins**2 / item**5). \\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins. \\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1]. \\n5. Return the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + np.exp(bins**2 / item**5)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the average capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_bin_cap = np.average(bins)\\n scores = (bins - avg_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on a modified formula, involving the bins and the item, and then computes a weight for each bin based on its score and the score of the previous bin, adjusting the weights based on the difference in scores between consecutive bins, and finally returning the resulting weights as scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (2 * (bins - np.average(bins))**2 / item) + 3 * (bins**2 / (item**2))\\n scores += 4 * (bins**2 / item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings):\\n\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores. However, in this new algorithm, we will modify the formula used to compute the scores to improve performance. The main steps include:\\n\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: ((bins - max_bin_cap)**2 / item) + ((bins**2 - max_bin_cap**2) / item**2) + ((bins**2 - max_bin_cap**3) / item**3).\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bin_caps = bins - np.max(bins)\\n scores = (bin_caps ** 2 / item) - (bins / item)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula that prioritizes bins closer in size to the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\\nMain steps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + 1000*(max_bin_cap - bins)**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / item**2 + 1000*(max_bin_cap - bins)**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities, but with a different parameter settings.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on their remaining capacity, index position, remaining capacity bias factor, and penalty term using a combination of exponential, logarithmic, and power functions, along with the square root of the absolute difference between the item size and the bin capacities. The parameters used are different from the original algorithm.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef revised_score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.abs(bins - item) + np.abs(np.arange(num_bins) - middle_index)\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to bins based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor, combined with a trigonometric function applied to the square root of the capacity, creating a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * np.sqrt(bins) / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.mean(bins)\\n scores = (bins - central_tendency)**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores. The main steps include: \\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the scores by using the formula: (bins - max_bin_cap)**2 / item + bins**2 / (item**2) + bins**2 / item**3.\\n3. Adjust the scores for bins greater than the item by setting the scores as negative for those bins.\\n4. Update the scores based on the differences between consecutive elements using the expression: scores[1:] -= scores[:-1].\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n central_tendency = np.median(bins)\\n scores = (bins - central_tendency)**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm assigns scores to each bin based on a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.exp(-np.abs(bins - item)) + np.cos(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on the bin's remaining capacity, the square of the absolute difference between the item size and the bin capacities, the exponential factor, the bin's position in the list, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sin(np.pi * bins / item) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms assign scores to bins based on a combination of factors such as the difference in capacity compared to the item size, the bin's position in the list, and various functions applied to the differences.\\n\\nNew algorithm description:\\nThe new algorithm assigns scores to bins based on the ratio between the remaining capacity of each bin and the item size, the logarithmic factor, and the square root of the absolute difference between the capacity and the item size, combined with penalty and reward terms to create a complex and effective scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n middle_index = (len(bins) - 1) // 2\\n\\n scores = np.log(bins / item) + np.sqrt(np.abs(bins - item)) + np.abs(np.arange(len(bins)) - middle_index) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their position in the list, and the square of the difference between the bin capacity and the item size, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities, but with a different parameter settings.\\n\\nNew algorithm:\\nThe new algorithm assigns scores to bins based on their remaining capacity, index position, remaining capacity bias factor, and penalty term using a combination of exponential, logarithmic, and power functions, along with the square root of the absolute difference between the item size and the bin capacities. The parameters used are different from the original algorithm.\\n\\nUpdated code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 3)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3)\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for the bins based on various factors such as the remaining capacity of the bins, the index position of the bins, and penalty/reward terms. These scores are then adjusted based on the difference between consecutive bins.\\n\\nMy new algorithm assigns scores to bins based on the remaining capacity of the bins, the index position of the bins, a penalty term that encourages using bins with higher remaining capacity, and a reward term that promotes using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and trigonometric functions, along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nHere is the implementation of the new score function in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) + np.sin(np.pi * bins / item)\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign higher scores to bins that have a remaining capacity close to the size of the item, while penalizing bins that are closer to maximum capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and absolute value functions to calculate the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.exp(-(np.abs(bins - item))) * np.log(max_capacity - bins) + np.sqrt(bins) + np.log(max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the beginning of the list using a combination of exponential, logarithmic, and absolute value functions, resulting in a more complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - (num_bins - 1))\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their remaining capacity, index position, and other penalties or rewards that encourage or discourage certain assignments.\\n\\nNew algorithm: The score function calculates the scores for each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, and the bin's position in the list. This promotes assigning the item to bins with lower remaining capacity, avoiding bins with maximum capacity, and prioritizing bins that have a capacity close to half the size of the item.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) + np.log(bins) - np.abs(bins - item) + (bins == max_capacity) * item + (bins == item) * item**2 + np.abs(bins - item * 0.5)\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the end of the list using a combination of exponential, logarithmic, and absolute value functions, resulting in a more complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n end_index = bins.size - 1\\n max_capacity = np.max(bins)\\n scores = np.exp(-(np.abs(bins - item))) * np.log(max_capacity - bins) + np.sqrt(bins) + np.log(max_capacity - bins + 1) + np.log(bins) + np.abs(end_index - np.arange(bins.size))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Modified score function\\n\\nThe algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a stronger reward for bins that have a capacity close to half the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - np.abs(bins - item) + (bins == max_capacity) * item + (bins == item) * item**2 + np.abs(bins - item * 0.5)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on their remaining capacity, their index position in the list, and various penalization factors to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity.\\n\\nNew algorithm description: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, and their difference from the item size, with additional penalization terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins while considering the item size.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) * np.log10(np.arange(bins.size)+1) - np.abs(bins - item)\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 - bins) - np.abs(bins - item) + (bins == np.max(bins)) * item + (bins >= item) * item\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a stronger reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) - np.abs(bins - item) + (np.max(bins) == bins) * item + (bins == item) * item**2\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity and their index position in the list, with additional penalization terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins. The algorithm also incorporates a logarithmic factor to further differentiate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) * np.log10(np.arange(bins.size)+1)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to prioritize bins that have a capacity close to the size of the item, while also penalizing bins that are close to maximum capacity, in order to minimize the number of used bins:\\n\\nAlgorithm description: The algorithm calculates the score for each bin based on the remaining capacity, with a larger penalty for bins that are close to maximum capacity, and a larger reward for bins that have a capacity close to the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - 2 * np.abs(bins - item) + 2 * (bins == max_capacity) * item + (bins >= item) * item\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on the remaining capacity, with a stronger penalty for bins that are close to maximum capacity, and a reward for bins that have a capacity close to half the size of the item, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins)**2 - np.abs(bins - item) + (bins == max_capacity) * item**2 + (bins == item) * item**3 - np.abs(bins - item * 0.5)**2\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to multiple bins to minimize the number of used bins, considering the rest capacities of the bins. The algorithm calculates the scores for each bin based on their rest capacities and assigns a portion of the item to each bin with a proportional score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for each bin based on their remaining capacities and some specific conditions or calculations.\\n\\nNew algorithm description: The algorithm calculates the scores for each bin based on the inverse of the rest capacity, the logarithm of the bin number, and a penalty for bins with maximum capacity, returning a Numpy array of scores for assignment.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n capacities = 1 / bins\\n log_bin_numbers = np.log(np.arange(1, num_bins + 1))\\n scores = capacities + log_bin_numbers\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, and an exponentially decaying factor, with additional penalization terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) * np.exp(np.arange(bins.size)*-0.1)\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, and a penalization factor that encourages using bins with lower remaining capacity and discourages using bins with maximum capacity. It also incorporates a logarithmic factor to further differentiate scores and a square root factor to emphasize smaller remaining capacity bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) * np.log10(np.arange(bins.size)+1) - np.sqrt(bins)\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The score function calculates the scores for each bin based on their remaining capacity, as well as characteristics such as index position in the list and penalization factors.\\n\\nNew algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, and a combination of exponential, logarithmic, and absolute value functions, resulting in a complex scoring system that promotes performance.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.exp(-np.abs(bins - item)**2) * np.log2(max_capacity - bins + 1) * (np.arange(bins.size) + 1)**2\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, and a penalization factor that encourages using bins with lower remaining capacity and discourages using bins with maximum capacity. It also incorporates a logarithmic factor to further differentiate scores.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) + np.log(bins)\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns the item to the bins based on their rest capacities, prioritizing bins with lower rest capacities and assigning a portion of the item proportional to the difference between the capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n rest_capacities = bins - item\\n scores = 1 / np.maximum(rest_capacities, 1)\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity and their index position in the list, with additional penalization terms to prioritize bins with lower remaining capacity and discourage using bins with maximum capacity, in order to minimize the number of used bins. The algorithm also incorporates a logarithmic factor to further differentiate scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size))\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, and a factor that encourages using bins with lower remaining capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms to achieve a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with additional penalty terms, to achieve a unique and effective scoring system.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the inverse difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, the inverse of the absolute difference of the bins from the item size, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins at the edges of the list while considering the item size using a combination of exponential, logarithmic, square root, and power functions, resulting in a highly intricate scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.power(np.abs(bins - item), 2) + 1)\\n return scores\",\n \"objective\": 0.02525,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, and a factor that encourages using bins with lower remaining capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms to achieve a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.02626,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, the logarithm of the absolute difference of the bins from the item size, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins at the edges of the list while considering the item size using a combination of exponential, logarithmic, square root, and power functions, resulting in a highly intricate scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.log(np.abs(bins - item) + 1) + 1)\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms calculate the scores for each bin based on their remaining capacity, with variations such as penalizing bins close to maximum capacity, rewarding bins with capacity close to the item size, and incorporating factors like index position, logarithmic transformations, and absolute value functions. \\n\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the middle of the list using a combination of exponential, logarithmic, and square root functions, resulting in a unique scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the remaining capacity of the bins, their index position in the list, the inverse of the absolute difference of the bins from the item size, and a penalization factor that encourages using bins with lower remaining capacity, while also discouraging using bins with maximum capacity and considering the item size using a combination of exponential, logarithmic, and power functions, resulting in a balanced and efficient scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.log(np.abs(np.arange(num_bins) - middle_index) + 1) + 1 / (np.power(np.abs(bins - item), 2) + 1)\\n scores = scores * np.log(bins + 2) * np.log(max_capacity - bins + 2)\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign higher scores to bins that have a remaining capacity close to the size of the item, while penalizing bins that are closer to maximum capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and absolute value functions to calculate the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.exp(-(np.abs(bins - item))) * np.log(max_capacity - bins) + np.sqrt(bins) + np.log(max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the beginning of the list using a combination of exponential, logarithmic, and absolute value functions, resulting in a more complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - (num_bins - 1))\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This new algorithm calculates the scores for each bin based on their remaining capacity, a penalization factor that encourages using bins with lower remaining capacity, and a reward factor that biases the scores towards bins with capacities that are closer to a fraction of the item size, using a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms, resulting in a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n\\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) - np.sqrt(np.abs(bins - item))\\n return scores\",\n \"objective\": 0.03572,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, their index position in the list, and a complex combination of mathematical functions, including exponential, logarithmic, and trigonometric functions, resulting in a highly intricate and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sin(bins) * np.log(np.sqrt(bins + 1) + 1) + np.cos(item - bins) * np.arctan(bins**2)\\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their remaining capacity, index position, and other penalties or rewards that encourage or discourage certain assignments.\\n\\nNew algorithm: The score function calculates the scores for each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, and the bin's position in the list. This promotes assigning the item to bins with lower remaining capacity, avoiding bins with maximum capacity, and prioritizing bins that have a capacity close to half the size of the item.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) + np.log(bins) - np.abs(bins - item) + (bins == max_capacity) * item + (bins == item) * item**2 + np.abs(bins - item * 0.5)\\n return scores\",\n \"objective\": 0.03632,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description:\\nThe new algorithm calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, square root, and absolute value functions, resulting in a unique scoring system.\\n\\nNew Algorithm Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n\\n # New Algorithm Parameters\\n penalization_factor = 0.5\\n fraction_factor = 0.8\\n \\n # Calculate scores using the new algorithm\\n scores = (np.exp(-np.abs(bins - item)) * (fraction_factor * item)) * np.sqrt(bins + 1) * (max_capacity - bins + 1) + (penalization_factor * np.abs(np.arange(num_bins) - middle_index))\\n \\n return scores\",\n \"objective\": 0.03753,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the common backbone idea, the new algorithm calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, square root, and absolute value functions, resulting in a unique scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.sqrt(bins + 1) * (max_capacity - bins + 1) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the end of the list using a combination of exponential, logarithmic, and absolute value functions, resulting in a more complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n end_index = bins.size - 1\\n max_capacity = np.max(bins)\\n scores = np.exp(-(np.abs(bins - item))) * np.log(max_capacity - bins) + np.sqrt(bins) + np.log(max_capacity - bins + 1) + np.log(bins) + np.abs(end_index - np.arange(bins.size))\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms all calculate scores for each bin based on the bin's remaining capacity, its index position in the list, and factors that encourage using bins with lower remaining capacity or biases scores towards bins with capacities close to a fraction of the item size using various mathematical functions.\\n\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the absolute difference between the item size and the bin capacities, using a combination of exponential, square root, logarithmic, and absolute value functions along with penalty terms and the absolute difference factor to create a complex and effective scoring system.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.sqrt(bins + 1) * np.log(max_capacity - bins + 1) * np.abs(max_capacity - bins - item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign higher scores to bins that have a remaining capacity close to half the size of the item, while penalizing bins that are closer to maximum capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and square root functions to calculate the scores, and also takes into account the index position of the bins to further refine the scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.exp(-(np.abs(bins - item*0.5))**2) * np.log(max_capacity - bins + 1) * np.sqrt(bins) * np.log(bins) * (np.arange(bins.size) + 1)**2\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: Modified score function\\n\\nThe algorithm calculates the score for each bin based on the remaining capacity, with a penalty for bins that are close to maximum capacity, and a stronger reward for bins that have a capacity close to half the size of the item, in order to minimize the number of used bins.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - np.abs(bins - item) + (bins == max_capacity) * item + (bins == item) * item**2 + np.abs(bins - item * 0.5)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the inverse difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, and a factor that encourages using bins with lower remaining capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms to achieve a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with additional penalty terms, to achieve a unique and effective scoring system.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on their remaining capacity, index position, and factors that consider the difference in capacity compared to the item size, the logarithmic factor, and the bin's position in the list.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with additional penalty terms.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5)\\n \\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the square root of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms to create a complex and effective scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.sqrt(np.abs(bins - item) + 0.5)\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the inverse difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the ratio between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the ratio factor to create a complex and effective scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(bins / item + 0.5)\\n return scores\",\n \"objective\": 0.02173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate scores for each bin based on its remaining capacity, index position, and various penalties or rewards that encourage or discourage certain assignments.\\n\\nNew algorithm: The score function calculates the scores for each bin based on their remaining capacity, index position, a penalization factor that encourages using bins with lower remaining capacity, and a reward factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms and the bin's index position.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + np.exp(-np.abs(np.log(bins) - np.log(item))**2) + (bins == item) * item**2 + np.exp(-np.sqrt(np.abs(bins - item)))\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, the inverse of the absolute difference of the bins from the item size, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins at the edges of the list while considering the item size using a combination of exponential, logarithmic, square root, and power functions, resulting in a highly intricate scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.power(np.abs(bins - item), 2) + 1)\\n return scores\",\n \"objective\": 0.02525,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a factor that encourages using bins with lower remaining capacity, and an additional penalty term that penalizes bins with high remaining capacity to promote the minimization of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.log1p(bins) + np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) - np.exp(-bins / item)\\n return scores\",\n \"objective\": 0.02535,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, and a factor that encourages using bins with lower remaining capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms to achieve a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.02626,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, the logarithm of the absolute difference of the bins from the item size, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins at the edges of the list while considering the item size using a combination of exponential, logarithmic, square root, and power functions, resulting in a highly intricate scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.log(np.abs(bins - item) + 1) + 1)\\n return scores\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: The existing algorithms calculate the scores for each bin based on their remaining capacity, with variations such as penalizing bins close to maximum capacity, rewarding bins with capacity close to the item size, and incorporating factors like index position, logarithmic transformations, and absolute value functions. \\n\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the middle of the list using a combination of exponential, logarithmic, and square root functions, resulting in a unique scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.02696,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and an additional factor based on the logarithm of the inverse of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, and power functions along with penalty terms to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + (np.log10(1 / np.abs(bins - item) + 1))**2 + (bins == max_capacity) * item + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5)\\n \\n return scores\",\n \"objective\": 0.03139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the remaining capacity of the bins, their index position in the list, the inverse of the absolute difference of the bins from the item size, and a penalization factor that encourages using bins with lower remaining capacity, while also discouraging using bins with maximum capacity and considering the item size using a combination of exponential, logarithmic, and power functions, resulting in a balanced and efficient scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.log(np.abs(np.arange(num_bins) - middle_index) + 1) + 1 / (np.power(np.abs(bins - item), 2) + 1)\\n scores = scores * np.log(bins + 2) * np.log(max_capacity - bins + 2)\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function calculates the scores for each bin based on the remaining capacity of the bins, their index position in the list, the logarithm of the inverse of the absolute difference of the bins from the item size, and a penalization factor that encourages using bins with lower remaining capacity, while also discouraging using bins with maximum capacity and considering the item size using a combination of exponential, logarithmic, and power functions, resulting in a balanced and efficient scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log10(1 / np.abs(bins - item) + 1) * np.log(max_capacity - bins + 1) + np.log(np.abs(np.arange(num_bins) - middle_index) + 1) + 1 / (np.power(np.abs(bins - item), 2) + 1)\\n scores = scores * np.log(bins + 2) * np.log(max_capacity - bins + 2)\\n \\n return scores\",\n \"objective\": 0.03189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign higher scores to bins that have a remaining capacity close to the size of the item, while penalizing bins that are closer to maximum capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and absolute value functions to calculate the scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.exp(-(np.abs(bins - item))) * np.log(max_capacity - bins) + np.sqrt(bins) + np.log(max_capacity - bins + 1)\\n return scores\",\n \"objective\": 0.03381,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, and the bin's position in the list. This promotes assigning the item to bins with lower remaining capacity, avoids bins with maximum capacity, and prioritizes bins that have a capacity close to half the size of the item.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins.max() - bins) + (bins == bins.max()) * (item - np.arange(bins.size)) + np.log(bins) - np.abs(bins - item) + (bins == max_capacity) * item + (bins == item) * item**2 + np.abs(bins - item * 0.5) + (bins == max_capacity/2) * item\\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n # New algorithm: Changing parameter settings\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1)**2 + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities, resulting in a highly intricate scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the index position, and various mathematical functions to create a complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) +\\n np.log(max_capacity - bins + 2) * np.sin(np.pi * bins / item) +\\n np.sqrt(bins + 1) +\\n np.log(bins + 2) +\\n np.abs(np.arange(bins.size) - bins.size // 2) +\\n 1/(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, index position, penalization factor that discourages using bins with higher remaining capacity, and a reward factor that biases the scores towards bins with capacities closer to a fraction of the item size, using a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms and the bin's index position, with modified parameters.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-(bins - item) / 2) * np.log(max_capacity - bins + 2) + (np.sqrt(bins) + 1) * np.log(bins + 2) + np.sin(np.pi / 2 * bins / item) + np.abs(np.arange(num_bins) - middle_index) + np.exp(-np.abs(np.log(bins) - np.log(item))**2) + (bins == item) * item**2 + np.exp(-np.sqrt(np.abs(bins - item) / 2))\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on their remaining capacity, index position, and factors that consider the relationship between capacity and item size.\\n\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the middle of the list, utilizing a combination of exponential, logarithmic, trigonometric, and absolute value functions.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5) + np.cos(item * np.pi / bins)\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the inverse difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, and a factor that encourages using bins with lower remaining capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms to achieve a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is that they assign scores to bins based on factors such as remaining capacity, index position, and the difference in capacity compared to the item size, using a combination of mathematical functions and penalty terms.\\n\\nNew algorithm: The score function calculates scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with additional penalty terms.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-(bins - item)**2) * np.log(np.abs(max_capacity - bins) + 1) + np.sin(np.pi * bins / item) + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(bins / item)\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the product between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the product factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/((item * bins) + 1)\\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on their remaining capacity, index position, and factors that consider the difference in capacity compared to the item size, the logarithmic factor, and the bin's position in the list.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with additional penalty terms.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5)\\n \\n return scores\",\n \"objective\": 0.01871,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the square root of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms to create a complex and effective scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.sqrt(np.abs(bins - item) + 0.5)\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the inverse difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(bins.size) - bins.size // 2) + 1/(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, and a factor that encourages using bins with lower remaining capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms to achieve a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-(bins - item)**2) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n \\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the inverse logarithmic difference factor to create a complex and effective scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor that promotes using bins with higher remaining capacity, using a combination of exponential, logarithmic, trigonometric, and square root functions along with penalty terms and the additional factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(bins / item)\\n return scores\",\n \"objective\": 0.02073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The current algorithms calculate scores for each bin based on the remaining capacity, index position, and factors that encourage using bins with lower capacity and biases scores towards bins with capacities close to a fraction of the item size.\\n\\nNew algorithm: The score function calculates the scores for each bin based on the remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, utilizing a combination of exponential, logarithmic, trigonometric, and absolute value functions along with additional penalty terms to achieve a unique and effective scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(avg_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.02113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, their index position in the list, a factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities, using a combination of exponential, logarithmic, and trigonometric functions along with penalty terms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-(bins - item)) * np.log(np.abs(mean_capacity - bins) + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the ratio between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the ratio factor to create a complex and effective scoring system.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(bins / item + 0.5)\\n return scores\",\n \"objective\": 0.02173,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, and a penalization factor that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and a factor based on the absolute difference between the item size and the bin capacities, resulting in a highly intricate scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(max_capacity - bins + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities, resulting in a highly intricate scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with lower remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities, resulting in a highly intricate scoring system. Only the parameter settings of the score function will be different.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * np.log(np.abs(mean_capacity - bins) + 1)**3 + np.sin(np.pi * bins / item)**3 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities. The modified algorithm introduces a new term that multiplies the previous scores by the square of the item size divided by the remaining capacity, with an additional logarithmic transformation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * np.log(np.abs(mean_capacity - bins) + 1)**3 + np.sin(np.pi * bins / item)**3 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) * np.log((item**2) / bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the index position, and various mathematical functions to create a complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) +\\n np.log(max_capacity - bins + 2) * np.sin(np.pi * bins / item) +\\n np.sqrt(bins + 1) +\\n np.log(bins + 2) +\\n np.abs(np.arange(bins.size) - bins.size // 2) +\\n 1/(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the inverse logarithmic difference factor to create a complex and effective scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(np.sqrt(bins + 1)) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with higher remaining capacity, a factor that biases the scores towards bins with capacities away from a fraction of the item size, and an additional factor based on the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the logarithmic difference factor to create a complex and effective scoring system.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.sqrt(bins + 1)**3) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item**2) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 2)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the remaining capacity, the index position, and various mathematical functions that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and additional penalty terms, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with modified parameters.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.log(max_capacity - bins + 2) * np.sin(np.pi * bins / item) + np.sqrt(bins + 1) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 1) + (np.exp(-np.abs(np.log(bins) - np.log(item))) * np.sin(np.pi * bins / item) * np.sqrt(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the index position, and various mathematical functions that consider the difference in capacity compared to the item size, the square-root factor, the bin's position in the list, and additional penalty terms, using a combination of exponential, logarithmic, and trigonometric functions along with modified parameters.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(max_capacity - bins + 2) * np.sin(np.pi * bins / item) + np.log(np.sqrt(bins + 1)) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 1) + (np.exp(-np.abs(np.log(bins) - np.log(item))) * np.sin(np.pi * bins / item) * np.sqrt(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the index position, and various mathematical functions to create a complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n\\n scores = (np.exp(-np.abs(bins - item)) * np.log(bins + 2) +\\n np.sqrt(bins + 1) +\\n np.log(bins + 2) +\\n np.abs(np.arange(bins.size) - bins.size // 2) +\\n 1/(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on their remaining capacity, index position, and factors that consider the relationship between capacity and item size.\\n\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, a factor that biases the scores towards bins closer to the middle of the list, and a factor that incorporates the reciprocal of the absolute difference between the bin capacity and the item size, utilizing a combination of exponential, logarithmic, trigonometric, and absolute value functions.\\n\\nCode:\\n\\n```\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5) + np.cos(item * np.pi / bins) + 1/(np.abs(bins - item) + 1)\\n \\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on their remaining capacity, index position, and factors that consider the relationship between capacity and item size.\\n\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that discourages using bins with maximum capacity, and a factor that biases the scores towards bins closer to the middle of the list, utilizing a combination of exponential, logarithmic, trigonometric, and absolute value functions.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5) + np.cos(item * np.pi / bins)\\n \\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the inverse difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, their index position in the list, and a factor that encourages using bins with lower remaining capacity, in order to minimize the number of used bins. It incorporates a combination of exponential, logarithmic, and trigonometric functions along with additional penalty terms to achieve a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index)\\n return scores\",\n \"objective\": 0.01801,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is that they assign scores to bins based on factors such as remaining capacity, index position, and the difference in capacity compared to the item size, using a combination of mathematical functions and penalty terms.\\n\\nNew algorithm: The score function calculates scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with additional penalty terms.\\n\\nCode for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n \\n scores = np.exp(-(bins - item)**2) * np.log(np.abs(np.max(bins) - bins) + 1) + np.sin(np.pi * bins / item) + np.log(bins + 1) + np.abs(np.arange(num_bins) - num_bins // 2) + np.sqrt(bins / item)\\n \\n return scores\",\n \"objective\": 0.01821,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the product between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms and the product factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/((item * bins) + 1)\\n return scores\",\n \"objective\": 0.01831,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, the index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the absolute difference between the item size and the bin capacities, resulting in a highly intricate scoring system.\\n\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with lower remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, power, and absolute value functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) + 1/(np.log(np.abs(bins - item) + 1) + 1)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The modified algorithm assigns scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities. Additionally, the modified algorithm introduces a new term that multiplies the previous scores by the square of the item size divided by the remaining capacity, with an additional logarithmic transformation and an exponential factor with parameter -2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * np.log(np.abs(mean_capacity - bins) + 1)**3 + np.sin(np.pi * bins / item)**3 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) * np.log((item**2) / bins) * np.log((item**2) / bins)**2 * np.exp(-2)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities. The modified algorithm introduces a new term that multiplies the previous scores by the square of the item size divided by the remaining capacity, with an additional logarithmic transformation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * np.log(np.abs(mean_capacity - bins) + 1)**3 + np.sin(np.pi * bins / item)**3 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) * np.log((item**2) / bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor to create a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * bins / item) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the index position, and various mathematical functions to create a complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) +\\n np.log(max_capacity - bins + 2) * np.sin(np.pi * bins / item) +\\n np.sqrt(bins + 1) +\\n np.log(bins + 2) +\\n np.abs(np.arange(bins.size) - bins.size // 2) +\\n 1/(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the inverse logarithmic difference factor to create a complex and effective scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(np.sqrt(bins + 1)) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the square root of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and square root functions along with penalty terms and the inverse logarithmic difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.sqrt(np.abs(bins - item)) * np.log(np.sqrt(bins + 1)) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with higher remaining capacity, a factor that biases the scores towards bins with capacities away from a fraction of the item size, and an additional factor based on the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the logarithmic difference factor to create a complex and effective scoring system.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.sqrt(bins + 1)**3) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item**2) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 2)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function calculates the scores for each bin based on the sum of the item size and the remaining capacity of the bins, the index position, a penalization factor encouraging the use of bins with lower remaining capacity, and a factor that biases the scores towards bins with capacities close to a fraction of the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-(item + bins)) * np.log(bins + 1) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.01097,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on a combination of the remaining capacity, the index position, and various mathematical functions that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and additional penalty terms, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with modified parameters.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.log(max_capacity - bins + 2) * np.sin(np.pi * bins / item) + np.sqrt(bins + 1) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 1) + (np.exp(-np.abs(np.log(bins) - np.log(item))) * np.sin(np.pi * bins / item) * np.sqrt(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.01117,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms assign scores to bins based on their remaining capacity, index position, and factors that consider the relationship between capacity and item size.\\n\\nNew Algorithm: The score function calculates the scores for each bin based on their remaining capacity, their index position in the list, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins closer to the maximum capacity, utilizing a combination of exponential, logarithmic, trigonometric, and absolute value functions.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 0.5) + np.cos(item * np.pi / bins) + np.exp(-np.abs(bins - max_capacity))\\n\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the remaining capacity, the index position, and various mathematical functions that consider the difference in capacity compared to the item size, the square-root factor, the bin's position in the list, and additional penalty terms, using a combination of exponential, logarithmic, and trigonometric functions along with modified parameters.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(max_capacity - bins + 2) * np.sin(np.pi * bins / item) + np.log(np.sqrt(bins + 1)) + np.log(bins + 2) + np.abs(np.arange(num_bins) - middle_index) + 1/(np.abs(bins - item) + 1) + (np.exp(-np.abs(np.log(bins) - np.log(item))) * np.sin(np.pi * bins / item) * np.sqrt(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.01177,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system. The only difference from the provided code is that the sine function is replaced with a cosine function.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n avg_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(avg_capacity - bins + 1) + np.log(1/(np.abs(bins - item) + 1)) + np.cos(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins + 1) + np.log(max_capacity - bins + 2) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to assign scores to bins based on their remaining capacity, the index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the absolute difference between the item size and the bin capacities, resulting in a highly intricate scoring system.\\n\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with lower remaining capacity, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * (np.log(bins + 1)**2) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item))\\n \\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the difference in capacity compared to the item size, the logarithmic factor, the bin's position in the list, and the absolute difference between the bin's capacity and the item size, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the absolute difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n \\n scores = np.exp(-np.abs(bins - item)) + np.sin(np.pi * bins / item) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, logarithmic, trigonometric, power, and absolute value functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.abs(mean_capacity - bins) + 1)**2 + np.sin(np.pi * bins / item)**2 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) + 1/(np.log(np.abs(bins - item) + 1) + 1)\\n \\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with higher remaining capacity, using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**3) * (np.log(bins + 2)**3) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*2)\\n\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The modified algorithm assigns scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities. Additionally, the modified algorithm introduces a new term that multiplies the previous scores by the square of the item size divided by the remaining capacity, with an additional logarithmic transformation and an exponential factor with parameter -2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * np.log(np.abs(mean_capacity - bins) + 1)**3 + np.sin(np.pi * bins / item)**3 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) * np.log((item**2) / bins) * np.log((item**2) / bins)**2 * np.exp(-2)\\n \\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, the logarithmic ratio of their capacity to the item size, a penalization factor that encourages using bins with lower remaining capacity, and a factor that biases the scores towards bins that are closer to the mean of the remaining capacities squared, using a combination of exponential, logarithmic, trigonometric, and power functions along with penalty terms and the square root of the absolute difference between the item size and the bin capacities. The modified algorithm introduces a new term that multiplies the previous scores by the square of the item size divided by the remaining capacity, with an additional logarithmic transformation.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n mean_capacity = np.mean(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**3) * np.log(np.abs(mean_capacity - bins) + 1)**3 + np.sin(np.pi * bins / item)**3 + np.log(bins + 1) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)) * np.log((item**2) / bins)\\n \\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description:\\nThe new algorithm assigns scores to each bin based on their remaining capacity, index position, and a combination of penalties and rewards that consider the product of the bin's remaining capacity and the item size, the absolute difference between the bin's capacity and the item size, the bin's position in the list, and the logarithmic factor, using a combination of exponential, logarithmic, trigonometric, and absolute value functions along with penalty terms, reward terms, and the inverse difference factor to create a complex and effective scoring system.\\n\\nNew Algorithm Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n max_capacity = np.max(bins)\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-bins * item) * np.log(max_capacity - bins + 1) + np.log(1/np.abs(bins - item) + 1) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + (np.log(bins + 1))**2 + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to bins based on their remaining capacity, their index position in the list, a factor that biases the scores towards bins with higher remaining capacity, and a penalty term that encourages using bins with lower remaining capacity using a combination of exponential, logarithmic, and power functions along with the square root of the absolute difference between the item size and the bin capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n\\n scores = np.exp(-np.abs(bins - item)**4) * (np.log(bins + 1)**4) + np.abs(np.arange(num_bins) - middle_index) + np.sqrt(np.abs(bins - item)*3)\\n\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on their remaining capacity, the difference between the item size and bin capacities, and the position of the bin in the list. \\n\\nNew algorithm description: The new algorithm assigns scores to bins based on their remaining capacity, the square root of the absolute difference between the item size and the bin capacities, the logarithmic factor, and a penalty term that encourages using bins with lower remaining capacity, using a combination of exponential, logarithmic, power, and absolute value functions along with penalty terms and the square root factor to create a complex and effective scoring system.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(bins + 1) + np.sqrt(np.abs(bins - item)) + np.log(np.abs(bins - item) + 1) + np.abs(np.arange(num_bins) - middle_index) + (np.log(np.abs(bins - item) + 1))**2 + (bins == item) * item**2\\n \\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's remaining capacity, its position in the list, and a combination of penalty and reward terms that consider the difference in capacity compared to the item size, the inverse of the absolute difference between the bin's capacity and the item size, the logarithmic factor, and the square root of the capacity, along with penalty terms, reward terms, and the inverse difference factor to create a unique and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n middle_index = len(bins) // 2\\n\\n scores = (bins - item) * np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) + np.sqrt(bins) + np.log(1/(np.abs(bins - item) + 1)) + np.abs(np.arange(len(bins)) - middle_index) + (np.log(bins + 1))**2 + np.sin(np.pi * bins / item) + (bins == item) * item**3\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, the index position, and various mathematical functions to create a complex scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n\\n scores = (np.exp(-np.abs(bins - item)) * np.log(max_capacity - bins + 1) +\\n np.log(max_capacity - bins + 2) * np.sin(np.pi * bins / item) +\\n np.sqrt(bins + 1) +\\n np.log(bins + 2) +\\n np.abs(np.arange(bins.size) - bins.size // 2) +\\n 1/(np.abs(bins - item) + 1))\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the inverse of the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the inverse logarithmic difference factor to create a complex and effective scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.log(np.sqrt(bins + 1)) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the natural logarithm of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and square root functions along with penalty terms and the inverse natural logarithmic difference factor to create a complex and effective scoring system.\\n\\nHere's the Python implementation of the new score function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.sqrt(np.abs(bins - item)) * np.log(np.abs(bins + 1)) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with lower remaining capacity, a factor that biases the scores towards bins with capacities close to a fraction of the item size, and an additional factor based on the square root of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and square root functions along with penalty terms and the inverse logarithmic difference factor to create a complex and effective scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)) * np.sqrt(np.abs(bins - item)) * np.log(np.sqrt(bins + 1)) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 1)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on their remaining capacity, the index position in the list, a penalization factor that encourages using bins with higher remaining capacity, a factor that biases the scores towards bins with capacities away from a fraction of the item size, and an additional factor based on the logarithmic function of the absolute difference between the item size and the bin capacities, using a combination of exponential, trigonometric, logarithmic, and absolute value functions along with penalty terms and the logarithmic difference factor to create a complex and effective scoring system.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = bins.size\\n middle_index = num_bins // 2\\n \\n scores = np.exp(-np.abs(bins - item)**2) * np.log(np.sqrt(bins + 1)**3) + np.sqrt(bins + 1) + np.log(bins + 2) + np.sin(np.pi * bins / item**2) + np.abs(np.arange(num_bins) - middle_index) + 1/np.log(np.abs(bins - item) + 2)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty array named 'scores' with the same length as the input array 'bins'.\\n2. Calculate the scores for each bin by taking the minimum between the rest capacity of the bin and the size of the item.\\n3. Set the score of a bin with maximum capacity to a very small negative value to prevent it from being used.\\n4. Return the 'scores' array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.minimum(bins, item)\\n max_capacity_bin_index = np.argmax(bins)\\n scores[max_capacity_bin_index] = -99999999\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the available capacity for each bin by subtracting the item size from the rest capacities of feasible bins. \\n2. Set the score for each bin to 0 if the available capacity is less than the item size, otherwise set the score to the available capacity. \\n3. If the rest capacity of a bin equals the maximum capacity, set the score to -1 to indicate that it will not be used. \\n4. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n scores = np.where(available_capacity < item, 0, available_capacity)\\n scores = np.where(bins == np.max(bins), -1, scores)\\n return scores\",\n \"objective\": 0.05795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm will calculate the score for each bin based on the rest capacity, using a weighted average of the rest capacity and the inverse of the bin number, then return the scores for each bin for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.arange(1, num_bins + 1)\\n normalized_capacity = 1 - (bins / np.max(bins))\\n scores = normalized_capacity * weights\\n return scores\",\n \"objective\": 0.05815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDefine a function named score that takes in inputs 'item' and 'bins' and returns the output 'scores' as a Numpy array, implementing a novel scoring algorithm to assign the item to the bins with the maximum score while minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n feasible_bins = np.where(bins >= item)[0]\\n \\n if len(feasible_bins) == 0:\\n return scores\\n \\n min_capacity = np.min(bins[feasible_bins])\\n \\n for i in feasible_bins:\\n if bins[i] == min_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = (bins[i] - item) / bins[i]\\n \\n return scores\",\n \"objective\": 0.06962,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the rest capacity, prioritizing bins with higher rest capacity and lower index, and returning a Numpy array of scores for assignment. \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) - (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.07073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe the algorithm:\\nThe score function takes an input item size and an array of rest capacities of feasible bins, and returns an array of scores for the bins, where the item will be assigned to the bin with the maximum score in each step, with the goal of minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n valid_bins = bins[bins != item] # remove bins with rest capacity equal to item size\\n\\n for i in range(valid_bins.shape[0]):\\n scores[i] = valid_bins[i] - item\\n\\n return scores\",\n \"objective\": 0.08693,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the scores for each bin using a novel scoring function based on the rest capacity and proximity to the item size, then returns the scores in a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm iterates through each bin, calculates the score for each bin based on the remaining capacity and the item size, and assigns the item to the bin with the maximum score. The scores for the bins are returned as an array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / bins\\n scores[bins == np.max(bins)] = -np.inf\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm consists of the following steps:\\n 1. Calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, subtracting 1 if the rest capacity equals the maximum capacity, and setting the score to 0 if the rest capacity is less than the item size.\\n 2. Return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / item) - (bins == bins.max())\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe score function will first calculate the scores for each bin by subtracting the rest capacity of the bin from the item size, giving a negative score if the rest capacity equals the maximum capacity, and then return the scores as a Numpy array.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item - bins\\n scores[bins == np.max(bins)] = -1\\n return scores\",\n \"objective\": 0.88067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function takes an item size and an array of bin capacities as input, and calculates a score for each bin based on its capacity, with higher capacity bins getting higher scores to minimize the number of used bins.\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item * (bins != item)) # Assigning infinite score to bins with equal capacity to item to prevent them from being used\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescribe your new algorithm and main steps here\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n mask = remaining_capacity >= item\\n scores = np.zeros_like(bins, dtype=float)\\n scores[mask] = remaining_capacity[mask] / (np.sum(bins) - np.sum(remaining_capacity))\\n return scores\",\n \"objective\": 0.92353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm will iterate through each bin and calculate its score based on the rest capacity, with a penalty applied when the rest capacity equals the maximum capacity, and then return the scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins - item) / max_capacity - 0.1 * (bins == max_capacity)\\n return scores\",\n \"objective\": 1.47862,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the remaining capacity of each bin after adding the item, then assigns a score to each bin based on the remaining capacity, and finally returns the scores for the bins for assignment as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n remaining_capacity[remaining_capacity == bins[0]] = 0 # Set the remaining capacity of full bins to 0\\n scores = remaining_capacity # Assign score based on remaining capacity\\n return scores\",\n \"objective\": 1.48375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm works by first calculating the available capacity for each bin after assigning the current item to it, then scoring each bin based on the remaining capacity with a penalty for reaching the maximum capacity, and finally returning the scores for all the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = np.maximum(0, bins - item)\\n penalty = (bins == max_capacity).astype(int)\\n scores = remaining_capacity - penalty\\n return scores\",\n \"objective\": 1.51524,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the remaining capacity of each bin after assignment of the current item. \\n2. Assign a score to each bin based on the remaining capacity, with a penalty for bins at maximum capacity. \\n3. Return the scores for the bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n penalty = np.where(remaining_capacity == 0, -np.inf, 0)\\n scores = remaining_capacity + penalty\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score to each bin based on the product of the remaining capacity and a factor that increases exponentially with the index of the bin, with a penalty term for bins close to the item size, to encourage the usage of larger bins and spread the items across different bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n num_bins = len(bins)\\n weights = np.exp(np.arange(num_bins, 0, -1)) # Exponential weights based on bin index\\n remaining_capacity = bins - item\\n scores = remaining_capacity * weights\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, but prioritize bins with a higher rest capacity and a lower index, by subtracting a weighted value from the scores. The final scores will be multiplied by an exponential decay factor to penalize bins with maximum capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, but limit the scores for bins with a higher rest capacity and a lower index to promote using bins with higher rest capacity and lower index.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n \\n # Limit the scores for bins with higher rest capacity and lower index\\n scores = ratios - (2 * np.arange(len(bins)))\\n \\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bin, a penalty for bins with maximum capacity, and the ratio between bin capacity and the item size, while also considering a constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item + (bins / item) * 0.5\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is calculating the ratio between the item size and each bin's rest capacity.\\n\\nNew algorithm:\\n1. Calculate the sum of the item size and each bin's rest capacity.\\n2. Calculate the ratio of the item size to the sum for each bin.\\n3. Calculate the score for each bin based on the ratio, the condition of the rest capacity, and the bin's index.\\n4. Return the scores for the bins for assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n sizes = item + bins\\n ratios = item / sizes\\n scores = ratios + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's rest capacity, but prioritizes bins with a higher index, and returns a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n ratios = item / bins[i]\\n scores[i] = ratios * (1 / (len(bins) - i))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms calculate scores for each bin based on the rest capacity of the bin compared to the size of the current item.\\n\\nNew Algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins while also considering the ratio between bin capacity and the item size, and applying randomization to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n random_nums = np.random.rand(bins.shape[0])\\n ratios = bins / item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + ratios * random_nums\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the rest capacity, the index, and the cumulative sum of the rest capacities, with higher scores assigned to bins with higher rest capacity, lower index, and larger cumulative sum.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) + (2 * np.arange(len(bins))) - np.cumsum(bins)\\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All of the provided algorithms calculate scores for each bin based on the remaining capacity of the bin compared to the size of the current item.\\n\\nNew algorithm: The new algorithm calculates the scores for each bin based on a combination of the remaining capacity, a penalty for bins with maximum capacity, and a random component, while also considering the ratio between bin capacity and the item size.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n ratios = bins / item\\n random_nums = np.random.rand(bins.shape[0])\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + ratios * random_nums\\n return scores\",\n \"objective\": 0.04357,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the ratio of each bin's rest capacity to the item size, and then apply additional modifications based on bin characteristics such as index, maximum capacity, or cumulative sum.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the square root of the ratio of each bin's rest capacity to the item size, multiplied by a factor that is inversely proportional to the index of the bin.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 1 / np.sqrt(np.arange(len(bins)) + 1)\\n \\n scores = np.sqrt(ratios) * weights\\n\\n return scores\",\n \"objective\": 0.04407,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, but prioritize bins with a higher index, and return a Numpy array of scores for assignment.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n num_bins = len(bins)\\n for i in range(num_bins-1, -1, -1):\\n ratios = bins[i] / item\\n scores[i] = ratios * (1 / (num_bins - i))\\n return scores\",\n \"objective\": 0.04417,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the rest capacity, the index, and the cumulative sum of the rest capacities, with higher scores assigned to bins with higher rest capacity, higher index, and larger cumulative sum.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 3 * bins * (bins == np.max(bins)) + (4 * np.arange(len(bins))) + 2 * np.cumsum(bins)\\n return scores\",\n \"objective\": 0.04487,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: \\n1. Calculate the cumulative sum of the rest capacities of the bins.\\n2. Calculate the difference between the cumulative sum and the maximum capacity of the bins.\\n3. Calculate the score for each bin based on the ratio of the rest capacity to the item size, the difference calculated in step 2, and the condition that the rest capacity is not equal to the maximum capacity of the bins.\\n4. Return the scores for the bins for assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n cum_sum = np.cumsum(bins)\\n max_cap_diff = cum_sum[-1] - bins\\n scores = bins / item + max_cap_diff / item\\n scores[bins == bins.max()] = 0\\n return scores\",\n \"objective\": 0.04618,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size and the difference between the rest capacity and the item size, but prioritize bins with a higher rest capacity and a lower index, by adding a weighted value to the scores. The final scores will be multiplied by an exponential decay factor to penalize bins with maximum capacity.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n differences = bins - item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios + differences + weights\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04759,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = item / bins[i]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm aims to assign the item to the bin that minimizes the cumulative sum of the remaining capacities of all previous bins, while still considering the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n \\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.3 # Changed penalty factor to 0.3\\n bonus_score = 15 # Changed bonus score to 15\\n decay_factor = 0.9 # Changed decay factor to 0.9\\n cumulative_sum = np.cumsum(bins)\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n \\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on a combination of the bin's rest capacity, the item size, a penalty factor for bins with lower capacities, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an adjustment based on the logarithm of the bin indices, with adjusted values for the penalty factor, bonus score, and decay factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n penalty_factor = 0.3 # Adjusted penalty factor\\n bonus_score = 25 # Adjusted bonus score\\n decay_factor = 0.9 # Adjusted decay factor\\n \\n scores = bins / (item + epsilon)\\n scores -= penalty_factor / (np.log(np.arange(1, len(bins) + 1)))\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / max_bin_cap)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices plus one, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 1 # Adjusted penalty_factor\\n bonus_score = 20 # Adjusted bonus_score\\n additional_factor = 0.5 # Adjusted additional_factor\\n decay_factor = 0.9 # Adjusted decay_factor\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= (decay_factor ** (np.cumsum(bins) / bins.max())) * (penalty_factor ** 2)\\n scores /= scores.sum() # Normalization factor\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.zeros(len(bins))\\n penalty_factor = 0\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm will calculate the scores for each bin based on a combination of the logarithm of the bin indices, the ratio of each bin's rest capacity to the item size, and the cumulative sum of rest capacities, while considering penalty factors for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor that promotes the usage of lower rest capacities. Additionally, the algorithm will incorporate a penalty for bins with rest capacity significantly larger than the item size, by applying a square root function to the ratio of the two.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 12\\n \\n ratio = bins / (item + epsilon)\\n penalty_factor = np.sqrt(ratio) # Adjusted ratio penalty\\n \\n scores = indices * ratio\\n scores -= 0.75 * (bins == bins.max())\\n scores -= 0.1 * penalty_factor * (bins > item) # Penalty for bins with rest capacity significantly larger than item size\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with adjustments based on factors like bin index, penalties for maximum capacity, bonuses for rest capacity equal to the item size, and additional factors such as logarithm of indices, cumulative sum of rest capacities, and decay factors.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional adjustments based on the bin index, rest capacity utilization, the cumulative sum of rest capacities, a penalty factor for bins with maximum capacity, logarithm of the bin indices, decay factor, and bonus score for bins with rest capacity equal to the item size, while also considering the inverse of the indices, exponential decay factor, and a factor that promotes the usage of lower rest capacities.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n bonus_score = 10\\n logarithm_indices = np.log(np.arange(1, len(bins) + 1))\\n additional_factor = 0.5\\n \\n scores = ratios\\n scores -= inverse_indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n scores += logarithm_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments based on factors such as bin index, cumulative sum of capacities, penalty factors, logarithmic terms, and bonus scores.\\n\\nNew Algorithm Description: The new algorithm will calculate the scores for each bin based on a combination of the logarithm of the bin indices, the ratio of each bin's rest capacity to the item size, and the cumulative sum of rest capacities, while considering penalty factors for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor that promotes the usage of lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 12\\n \\n scores = indices * bins / (item + epsilon)\\n scores -= 0.75 * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the cumulative sum of rest capacities raised to a power, and an adjustment based on a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a decay factor that gradually decreases the score contribution of higher rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.8\\n \\n scores = indices * bins / (item + epsilon)\\n scores -= 0.6 * (bins == bins.max()) # Simplified penalty_factor\\n scores += 20 * (bins == item) # Simplified bonus_score\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n\\n scores = ratios - inverse_indices\\n scores -= 0.7 * (bins == bins.max())\\n scores += 20 * (bins == item)\\n scores += 0.3 * (1 - ratios)\\n scores *= 0.9 ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments considering the bin indices, penalties for bins with maximum capacity, bonus scores for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.arange(len(bins)) # Simplified component: Initialize indices as range from 0 to len(bins)-1\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n\\n scores = bins / (item + epsilon) + np.log(indices + 1)\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone Idea: The common backbone idea in all the provided algorithms is to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.7\\n bonus_score = 20\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with higher indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities divided by the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n bonus_score = 15\\n decay_factor = 0.85\\n cumulative_sum = np.cumsum(bins)\\n max_capacity = bins.max()\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == max_capacity)\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / max_capacity)\\n scores *= (cumulative_sum / max_capacity)\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n bonus_score = 15\\n decay_factor = 0.85\\n cumulative_sum = np.cumsum(bins)\\n max_capacity = bins.max()\\n \\n penalty_scores = bins == max_capacity\\n bonus_scores = bins == item\\n\\n scores = ratios - inverse_indices\\n scores -= penalty_scores * penalty_factor\\n scores += bonus_scores * bonus_score\\n scores *= decay_factor ** (cumulative_sum / max_capacity)\\n scores *= (cumulative_sum / max_capacity)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 10 # Changed bonus score to 10\\n decay_factor = 0.95 # Changed decay factor to 0.95\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the exponential decay factor raised to the power of the cumulative sum of the rest capacities, a bonus score for bins with rest capacities equal to the item size, and a penalty factor for bins with maximum capacity, while also applying additional adjustments based on the bin indices and the ratio of each bin's rest capacity to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 10\\n penalty_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins == bins.max())\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the score for each bin based on the ratio of each bin's remaining capacity to the item size, with an additional bonus score for bins with rest capacity equal to the item size, an inverse bonus score for bins with higher indices, and a decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n \\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n bonus_score = 20\\n inverse_bonus_score = -10\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios\\n scores += bonus_score * (bins == item)\\n scores += inverse_bonus_score * inverse_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking into account the ratio between the item's size and each bin's rest capacity, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a modified cumulative sum of the rest capacities that accounts for the decay rate over time.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 100 # Simplified scaling factor for ratios\\n\\n ratios = bins / (item * scaling_factor)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = np.exp(-0.05 * (cumulative_sum / bins.max())) # Simplified decay factor\\n\\n scores = ratios\\n scores += 10 * (bins == item)\\n scores *= decay_factor\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with an increased penalty factor for bins with lower indices, a larger bonus score for bins with rest capacity equal to the item size, and a higher exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 1.2\\n bonus_score = 30\\n decay_factor = 0.95\\n cumulative_sum = np.cumsum(bins)\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on a combination of the bin's rest capacity, the item size, a penalty factor for bins with lower capacities, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an adjustment based on the logarithm of the bin indices, with adjusted values for the penalty factor, bonus score, and decay factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n penalty_factor = 0.3 # Adjusted penalty factor\\n bonus_score = 25 # Adjusted bonus score\\n decay_factor = 0.9 # Adjusted decay factor\\n \\n scores = bins / (item + epsilon)\\n scores -= penalty_factor / (np.log(np.arange(1, len(bins) + 1)))\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / max_bin_cap)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the natural logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 1\\n bonus_score = 20\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= (decay_factor ** (np.cumsum(bins) / bins.max())) * (penalty_factor ** 2)\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.zeros(len(bins))\\n penalty_factor = 0\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on its remaining capacity compared to the maximum capacity, by penalizing bins that are close to full, and then adjusts the scores based on the difference between consecutive elements.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n remaining_cap = max_bin_cap - bins\\n capacity_penalty = 0.2 * remaining_cap / max_bin_cap\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += capacity_penalty**2\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew algorithm description:\\nThis new algorithm adjusts the score calculation in the original algorithm by adding a penalty term that takes into account the remaining capacity of each bin, giving higher scores to bins with higher capacity left compared to the maximum capacity.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n bin_cap_ratio = bins / max_bin_cap\\n capacity_penalty = 0.2 * bin_cap_ratio\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += capacity_penalty**2\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments based on factors such as bin index, cumulative sum of capacities, penalty factors, logarithmic terms, and bonus scores.\\n\\nNew Algorithm Description: The new algorithm will calculate the scores for each bin based on a combination of the logarithm of the bin indices, the ratio of each bin's rest capacity to the item size, and the cumulative sum of rest capacities, while considering penalty factors for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor that promotes the usage of lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n decay_factor = 0.9\\n bonus_score = 12\\n \\n scores = np.log(range(1, len(bins) + 1)) * bins / (item + epsilon)\\n scores -= np.where(bins == bins.max(), 0.75, 0)\\n scores += np.where(bins == item, bonus_score, 0)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the cumulative sum of rest capacities raised to a power, and an adjustment based on a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a decay factor that gradually decreases the score contribution of higher rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.8\\n \\n scores = indices * bins / (item + epsilon)\\n scores -= 0.6 * (bins == bins.max()) # Simplified penalty_factor\\n scores += 20 * (bins == item) # Simplified bonus_score\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n\\n scores = ratios - inverse_indices\\n scores -= 0.7 * (bins == bins.max())\\n scores += 20 * (bins == item)\\n scores += 0.3 * (1 - ratios)\\n scores *= 0.9 ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments considering the bin indices, penalties for bins with maximum capacity, bonus scores for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.arange(len(bins)) # Simplified component: Initialize indices as range from 0 to len(bins)-1\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n\\n scores = bins / (item + epsilon) + np.log(indices + 1)\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone Idea: The common backbone idea in all the provided algorithms is to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, penalty_factor=0.7, bonus_score=20, decay_factor=0.9):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.sqrt(np.arange(len(bins)) + 1)\\n penalty_factor = 1\\n bonus_score = 20\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= (decay_factor ** (np.cumsum(bins) / bins.max())) * (penalty_factor ** 2)\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, additional factor, logarithmic term, and decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 0.2\\n bonus_score = 10\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 10 # Changed bonus score to 10\\n decay_factor = 0.95 # Changed decay factor to 0.95\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the exponential decay factor raised to the power of the cumulative sum of the rest capacities, a bonus score for bins with rest capacities equal to the item size, and a penalty factor for bins with maximum capacity, while also applying additional adjustments based on the bin indices and the ratio of each bin's rest capacity to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 10\\n penalty_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins == bins.max())\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the score for each bin based on the ratio of each bin's remaining capacity to the item size, with an additional bonus score for bins with rest capacity equal to the item size, an inverse bonus score for bins with higher indices, and a decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n \\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n bonus_score = 20\\n inverse_bonus_score = -10\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios\\n scores += bonus_score * (bins == item)\\n scores += inverse_bonus_score * inverse_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking into account the ratio between the item's size and each bin's rest capacity, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a modified cumulative sum of the rest capacities that accounts for the decay rate over time.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 100 # Simplified scaling factor for ratios\\n\\n ratios = bins / (item * scaling_factor)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = np.exp(-0.05 * (cumulative_sum / bins.max())) # Simplified decay factor\\n\\n scores = ratios\\n scores += 10 * (bins == item)\\n scores *= decay_factor\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm will calculate the scores for each bin based on a combination of the bin's rest capacity, the item size, a penalty factor for bins with lower capacities, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an adjustment based on the logarithm of the bin indices, with adjusted values for the penalty factor, bonus score, and decay factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 \\n penalty_factor = 0.3\\n bonus_score = 25\\n decay_factor = 0.9\\n \\n scores = bins / (item + epsilon)\\n scores -= penalty_factor / (np.log(np.arange(1, len(bins) + 1)))\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / max_bin_cap)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the natural logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 1\\n bonus_score = 20\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= (decay_factor ** (np.cumsum(bins) / bins.max())) * (penalty_factor ** 2)\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores with a penalty for bins that are close to full.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = ((1 / item**2) * (bins - max_capacity)**2 + (1 / item**3) * bins**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= (1 / bins) * ((max_capacity - bins / 2) / max_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for each bin based on its remaining capacity compared to the maximum capacity, by penalizing bins that are close to full, and then adjusts the scores based on the difference between consecutive elements.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n reference_cap = 100 # a fixed reference capacity value\\n remaining_cap = reference_cap - bins\\n capacity_penalty = 0.2 * remaining_cap / reference_cap\\n scores = (bins - reference_cap)**2 / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += capacity_penalty**2\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew algorithm description:\\nThis new algorithm adjusts the score calculation in the original algorithm by adding a penalty term that takes into account the remaining capacity of each bin, giving higher scores to bins with higher capacity left compared to the maximum capacity.\\n\\nCode: \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n bin_cap_ratio = bins / max_bin_cap\\n capacity_penalty = 0.2 * bin_cap_ratio\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += capacity_penalty**2\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe algorithm assigns a score for each bin based on its comparison with the item size, considering the rest capacities of the bins and aiming to minimize the number of used bins. \\n\\n1. Calculate the maximum capacity of the bins using the \\\"bins\\\" array. \\n2. Compute the score for each bin using the following steps:\\n a. Subtract the maximum bin capacity from the rest capacities of the bins and square the result.\\n b. Divide the squared result by the item size.\\n c. Square the rest capacities of the bins and divide by the square of the item size.\\n d. Divide the squared rest capacities of the bins by the cube of the item size.\\n e. If the rest capacity of a bin is greater than the item size, negate the score.\\n f. Subtract the score of each bin from the score of the previous bin.\\n3. Return the resulting scores for the bins.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = ((bins - max_bin_cap)**2 / item) + (bins**2 / (item**2))\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the cumulative sum of rest capacities raised to a power, and an adjustment based on a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a decay factor that gradually decreases the score contribution of higher rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.8\\n \\n scores = indices * bins / (item + epsilon)\\n scores -= 0.6 * (bins == bins.max()) # Simplified penalty_factor\\n scores += 20 * (bins == item) # Simplified bonus_score\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n\\n scores = ratios - inverse_indices\\n scores -= 0.7 * (bins == bins.max())\\n scores += 20 * (bins == item)\\n scores += 0.3 * (1 - ratios)\\n scores *= 0.9 ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n\\n scores = ratios - inverse_indices\\n scores -= 0.7 * np.ones_like(bins)\\n scores += 20 * np.where(bins == item, np.ones_like(bins), np.zeros_like(bins))\\n scores += 0.3 * (1 - ratios)\\n scores *= 0.9 ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, additional factor, logarithmic term, and decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 0.2\\n bonus_score = 10\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 10 # Changed bonus score to 10\\n decay_factor = 0.95 # Changed decay factor to 0.95\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the exponential decay factor raised to the power of the cumulative sum of the rest capacities, a bonus score for bins with rest capacities equal to the item size, and a penalty factor for bins with maximum capacity, while also applying additional adjustments based on the bin indices and the ratio of each bin's rest capacity to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 10\\n penalty_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins == bins.max())\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nThe new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size squared, the bin indices raised to the power of 0.75, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size squared, an additional factor that encourages the utilization of bins with lower rest capacities squared, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.sqrt(np.arange(len(bins)) + 1)**0.75\\n penalty_factor = 1\\n bonus_score = 20\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins**2 / (item + epsilon)**2 + indices\\n scores += bonus_score * (bins == item)**2\\n scores += additional_factor * (1 - bins / (item + epsilon))**2\\n scores *= (decay_factor ** (np.cumsum(bins) / bins.max())) * (penalty_factor ** 2)\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking into account the ratio between the item's size and each bin's rest capacity, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a modified cumulative sum of the rest capacities that accounts for the decay rate over time.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 100 # Simplified scaling factor for ratios\\n\\n ratios = bins / (item * scaling_factor)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = np.exp(-0.05 * (cumulative_sum / bins.max())) # Simplified decay factor\\n\\n scores = ratios\\n scores += 10 * (bins == item)\\n scores *= decay_factor\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int) # Change penalty value from 0.8 to 0.9\\n scores += 0.1 * penalty * max(scores) # Change penalty factor from 0.05 to 0.1\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on the previous algorithm but with different parameter settings. It calculates the score for a given item by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item. The scores are adjusted for bins greater than the item, and penalties are added for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**3) * (bins - max_capacity)**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.1 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap) ** 2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the natural logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n\\n scores = bins / (item + epsilon) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + epsilon))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * (1 ** 2)\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores with a penalty for bins that are close to full.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = ((1 / item**2) * (bins - max_capacity)**2 + (1 / item**3) * bins**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= (1 / bins) * ((max_capacity - bins / 2) / max_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.2 * penalty * max(scores) # Revised penalty factor to 0.2\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score for each bin based on its comparison with the item size, considering the rest capacities of the bins and aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = ((bins - max_bin_cap)**2 / item) + ((max_bin_cap - bins)**2 / item)\\n scores += bins / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n\\nThe algorithm assigns a score for each bin based on its comparison with the item size, considering the rest capacities of the bins and aiming to minimize the number of used bins. \\n\\n1. Calculate the maximum capacity of the bins using the \\\"bins\\\" array. \\n2. Compute the score for each bin using the following steps:\\n a. Subtract the maximum bin capacity from the rest capacities of the bins and square the result.\\n b. Divide the squared result by the item size.\\n c. Square the rest capacities of the bins and divide by the square of the item size.\\n d. Divide the squared rest capacities of the bins by the cube of the item size.\\n e. If the rest capacity of a bin is greater than the item size, negate the score.\\n f. Subtract the score of each bin from the score of the previous bin.\\n3. Return the resulting scores for the bins.\\n\\nImplementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = ((bins - max_bin_cap)**2 / item) + (bins**2 / (item**2))\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 0.2 * (bins == bins.max())**2\\n scores += 25 * (bins == item)\\n scores += 0.7 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 5\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n\\n scores = ratios - inverse_indices\\n scores -= 0.7 * np.ones_like(bins)\\n scores += 20 * np.where(bins == item, np.ones_like(bins), np.zeros_like(bins))\\n scores += 0.3 * (1 - ratios)\\n scores *= 0.9 ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, additional factor, logarithmic term, and decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 0.2\\n bonus_score = 10\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 10 # Changed bonus score to 10\\n decay_factor = 0.95 # Changed decay factor to 0.95\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the exponential decay factor raised to the power of the cumulative sum of the rest capacities, a bonus score for bins with rest capacities equal to the item size, and a penalty factor for bins with maximum capacity, while also applying additional adjustments based on the bin indices and the ratio of each bin's rest capacity to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 10\\n penalty_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins == bins.max())\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int) # Change penalty value from 0.8 to 0.9\\n scores += 0.1 * penalty * max(scores) # Change penalty factor from 0.05 to 0.1\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on the previous algorithm but with different parameter settings. It calculates the score for a given item by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item. The scores are adjusted for bins greater than the item, and penalties are added for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**3) * (bins - max_capacity)**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.1 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap) ** 2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the natural logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n\\n scores = bins / (item + epsilon) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + epsilon))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * (1 ** 2)\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores with a penalty for bins that are close to full.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = ((1 / item**2) * (bins - max_capacity)**2 + (1 / item**3) * bins**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= (1 / bins) * ((max_capacity - bins / 2) / max_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.2 * penalty * max(scores) # Revised penalty factor to 0.2\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score for each bin based on its comparison with the item size, considering the rest capacities of the bins and aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = ((bins - max_bin_cap)**2 / item) + ((max_bin_cap - bins)**2 / item)\\n scores += bins / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to assign higher scores to bins that are closer in capacity to the size of the item, and lower scores to bins that are significantly larger. The main steps of the algorithm are as follows:\\n\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using a formula involving the bins and the item size.\\n3. Adjust the scores for bins that are larger than the item size.\\n4. Update the scores based on the differences between consecutive elements.\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new algorithm as a function named \\\"score\\\" in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 0.2 * (bins == bins.max())\\n scores += 25 * (bins == item)\\n scores += 0.7 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 5\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins))**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1].copy()\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n\\n scores = ratios - inverse_indices\\n scores -= 0.7 * np.ones_like(bins)\\n scores += 20 * np.where(bins == item, np.ones_like(bins), np.zeros_like(bins))\\n scores += 0.3 * (1 - ratios)\\n scores *= 0.9 ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, additional factor, logarithmic term, and decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 0.2\\n bonus_score = 10\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 10 # Changed bonus score to 10\\n decay_factor = 0.95 # Changed decay factor to 0.95\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the exponential decay factor raised to the power of the cumulative sum of the rest capacities, a bonus score for bins with rest capacities equal to the item size, and a penalty factor for bins with maximum capacity, while also applying additional adjustments based on the bin indices and the ratio of each bin's rest capacity to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 10\\n penalty_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins == bins.max())\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.85 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00523,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int) # Change penalty value from 0.8 to 0.9\\n scores += 0.1 * penalty * max(scores) # Change penalty factor from 0.05 to 0.1\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on the previous algorithm but with different parameter settings. It calculates the score for a given item by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item. The scores are adjusted for bins greater than the item, and penalties are added for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**3) * (bins - max_capacity)**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.1 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full. It also introduces a new parameter 'alpha' that controls the impact of the penalty term.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins, alpha=0.1):\\n max_capacity = np.max(bins)\\n \\n # Calculate score based on bin-item comparisons\\n scores = (bins - max_capacity)**2 / item + bins**2 / (item**2)\\n \\n # Adjust scores for bins greater than the item\\n scores[bins > item] = -scores[bins > item]\\n \\n # Update scores based on differences between consecutive elements\\n scores[1:] -= scores[:-1]\\n \\n # Add penalty for bins that are close to full\\n scores += alpha * (bins / max_capacity)**2\\n \\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap) ** 2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the natural logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n\\n scores = bins / (item + epsilon) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + epsilon))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * (1 ** 2)\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores with a penalty for bins that are close to full.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = ((1 / item**2) * (bins - max_capacity)**2 + (1 / item**3) * bins**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= (1 / bins) * ((max_capacity - bins / 2) / max_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size combined with a penalty factor, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency in the scoring process.\\n\\nHere is the implementation of the new algorithm as a Python function named \\\"score\\\":\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item) - 10 * (bins == item)\\n scores += 0.3 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns a score for each bin based on its comparison with the item size, considering the rest capacities of the bins and aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores = ((bins - max_bin_cap)**2 / item) + ((max_bin_cap - bins)**2 / item)\\n scores += bins / item\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.log(1 + bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to assign higher scores to bins that are closer in capacity to the size of the item, and lower scores to bins that are significantly larger. The main steps of the algorithm are as follows:\\n\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using a formula involving the bins and the item size.\\n3. Adjust the scores for bins that are larger than the item size.\\n4. Update the scores based on the differences between consecutive elements.\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new algorithm as a function named \\\"score\\\" in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 0.2 * (bins == bins.max())\\n scores += 25 * (bins == item)\\n scores += 0.7 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 5\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins))**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1].copy()\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: \\nThe provided algorithms assign scores to each bin based on a comparison with the item size, considering the rest capacities of the bins. The goal is to minimize the number of used bins.\\n\\nNew algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.log(bins / (item + 1e-6)) + 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / max_bin_cap)) * 4\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, additional factor, logarithmic term, and decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 0.2\\n bonus_score = 10\\n additional_factor = 0.5\\n decay_factor = 0.9\\n\\n scores = bins / (item + epsilon) + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.85 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00523,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_scores = (bins - max_capacity) ** 2 / item**2\\n diff_scores[bins > item] = -diff_scores[bins > item]\\n diff_scores[1:] -= diff_scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores = diff_scores + 0.1 * penalty * max(diff_scores)\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on the previous algorithm but with different parameter settings. It calculates the score for a given item by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item. The scores are adjusted for bins greater than the item, and penalties are added for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**3) * (bins - max_capacity)**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.1 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All the algorithms calculate a score for a given item based on its comparison with a list of bins, adjusting the scores for bins greater than the item, and updating the scores based on differences between consecutive elements.\\n\\nNew Algorithm Description: The new algorithm calculates the score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item and penalties for bins that are close to full, and updating the scores based on the differences between consecutive elements.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (1 / item**2) * (bins - max_bin_cap)**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = np.exp(-0.1 * bins / max_bin_cap)\\n scores += 0.2 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, penalizes bins that are close to full, and finally returns the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity close to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and a normalization factor based on the sum of the scores to maintain self-consistency.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (np.isclose(bins, item, rtol=0.01, atol=0.01))\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max()))\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the differences between consecutive elements, and finally returning the resulting scores with a penalty for bins that are close to full.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = ((1 / item**2) * (bins - max_capacity)**2 + (1 / item**3) * bins**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores -= (1 / bins) * ((max_capacity - bins / 2) / max_capacity)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size combined with a penalty factor, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency in the scoring process.\\n\\nHere is the implementation of the new algorithm as a Python function named \\\"score\\\":\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item) - 10 * (bins == item)\\n scores += 0.3 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = 2 * np.log(bins / (item + 1e-6)) + 10 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / max_bin_cap)) * 5\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.log(1 + bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to assign higher scores to bins that are closer in capacity to the size of the item, and lower scores to bins that are significantly larger. The main steps of the algorithm are as follows:\\n\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using a formula involving the bins and the item size.\\n3. Adjust the scores for bins that are larger than the item size.\\n4. Update the scores based on the differences between consecutive elements.\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new algorithm as a function named \\\"score\\\" in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities through a logarithmic function.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += np.log(np.log(bins + 1)) / 10\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins))**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1].copy()\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: \\nThe provided algorithms assign scores to each bin based on a comparison with the item size, considering the rest capacities of the bins. The goal is to minimize the number of used bins.\\n\\nNew algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.log(bins / (item + 1e-6)) + 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / max_bin_cap)) * 4\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for a given item by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item. The scores are adjusted for bins greater than the item, and penalties are added for bins that are close to full. The penalty term is modified to include the difference between the current bin capacity and the maximum capacity of the bins, and a new parameter is introduced to control the penalty weight.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**3) * (bins - max_capacity)**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins - max_capacity) / max_capacity\\n scores += 0.5 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.85 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00523,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.05 * (np.log(1 + bins) / max_bin_cap) * max(scores)\\n return scores\",\n \"objective\": 0.00543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_scores = (bins - max_capacity) ** 2 / item**2\\n diff_scores[bins > item] = -diff_scores[bins > item]\\n diff_scores[1:] -= diff_scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores = diff_scores + 0.1 * penalty * max(diff_scores)\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on the previous algorithm but with different parameter settings. It calculates the score for a given item by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item. The scores are adjusted for bins greater than the item, and penalties are added for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**3) * (bins - max_capacity)**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.1 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All the algorithms calculate a score for a given item based on its comparison with a list of bins, adjusting the scores for bins greater than the item, and updating the scores based on differences between consecutive elements.\\n\\nNew Algorithm Description: The new algorithm calculates the score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item and penalties for bins that are close to full, and updating the scores based on the differences between consecutive elements.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (1 / item**2) * (bins - max_bin_cap)**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = np.exp(-0.1 * bins / max_bin_cap)\\n scores += 0.2 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, penalizes bins that are close to full, and finally returns the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and penalizes bins that are close to full based on a sigmoid function.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size combined with a penalty factor, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency in the scoring process.\\n\\nHere is the implementation of the new algorithm as a Python function named \\\"score\\\":\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item) - 10 * (bins == item)\\n scores += 0.3 * (1 - bins / item)\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = 2 * np.log(bins / (item + 1e-6)) + 10 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / max_bin_cap)) * 5\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.log(1 + bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to assign higher scores to bins that are closer in capacity to the size of the item, and lower scores to bins that are significantly larger. The main steps of the algorithm are as follows:\\n\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using a formula involving the bins and the item size.\\n3. Adjust the scores for bins that are larger than the item size.\\n4. Update the scores based on the differences between consecutive elements.\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new algorithm as a function named \\\"score\\\" in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities through a logarithmic function.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += np.log(np.log(bins + 1)) / 10\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins))**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1].copy()\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: \\nThe provided algorithms assign scores to each bin based on a comparison with the item size, considering the rest capacities of the bins. The goal is to minimize the number of used bins.\\n\\nNew algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.log(bins / (item + 1e-6)) + 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / max_bin_cap)) * 4\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.85 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00523,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.05 * (np.log(1 + bins) / max_bin_cap) * max(scores)\\n return scores\",\n \"objective\": 0.00543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter.\\n\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n diff_scores = (bins - max_capacity) ** 2 / item**2\\n diff_scores[bins > item] = -diff_scores[bins > item]\\n diff_scores[1:] -= diff_scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores = diff_scores + 0.1 * penalty * max(diff_scores)\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on the previous algorithm but with different parameter settings. It calculates the score for a given item by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item. The scores are adjusted for bins greater than the item, and penalties are added for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**3) * (bins - max_capacity)**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.9 * max(bins))).astype(int)\\n scores += 0.1 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: All the algorithms calculate a score for a given item based on its comparison with a list of bins, adjusting the scores for bins greater than the item, and updating the scores based on differences between consecutive elements.\\n\\nNew Algorithm Description: The new algorithm calculates the score for a given item based on a modified formula involving the bins and the item, adjusting the scores for bins greater than the item and penalties for bins that are close to full, and updating the scores based on the differences between consecutive elements.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (1 / item**2) * (bins - max_bin_cap)**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = np.exp(-0.1 * bins / max_bin_cap)\\n scores += 0.2 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, penalizes bins that are close to full, and finally returns the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and penalizes bins that are close to full based on a sigmoid function.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size combined with a penalty factor, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency in the scoring process.\\n\\nHere is the implementation of the new algorithm as a Python function named \\\"score\\\":\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item) - 10 * (bins == item)\\n scores += 0.3 * (1 - bins / item)\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = 2 * np.log(bins / (item + 1)) + 10 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1))\\n scores *= (0.9 ** (np.cumsum(bins) / max_bin_cap)) * 5\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.log(1 + bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to assign higher scores to bins that are closer in capacity to the size of the item, and lower scores to bins that are significantly larger. The main steps of the algorithm are as follows:\\n\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using a formula involving the bins and the item size.\\n3. Adjust the scores for bins that are larger than the item size.\\n4. Update the scores based on the differences between consecutive elements.\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new algorithm as a function named \\\"score\\\" in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description:\\nThe new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, penalizes bins that are close to full based on a sigmoid function, and modifies the scoring parameters to optimize the assignment process and minimize the number of used bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / (max_bin_cap/2))) - 0.75\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities through a logarithmic function.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += np.log(np.log(bins + 1)) / 10\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins))**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1].copy()\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: \\nThe provided algorithms assign scores to each bin based on a comparison with the item size, considering the rest capacities of the bins. The goal is to minimize the number of used bins.\\n\\nNew algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.log(bins / (item + 1e-6)) + 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / max_bin_cap)) * 4\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - np.max(bins))**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.85 * np.max(bins)))\\n scores += 0.05 * penalty * np.max(scores)\\n return scores\",\n \"objective\": 0.00523,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the exponential function of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nMain Steps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the initial score for each bin using the provided formula: (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2.\\n3. Adjust the scores for bins greater than the item by setting their scores to the negative of their original scores.\\n4. Update the scores based on the differences between consecutive elements by subtracting each score from the previous score.\\n5. Add a penalty to the scores for bins that are close to full by multiplying the scores by a penalty factor (e.g., 0.9) if the bin capacity is within a certain threshold (e.g., 10% of the maximum capacity).\\n6. Return the resulting scores as a Numpy array.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**2) * (bins - max_capacity)**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty_threshold = 0.1 * max_capacity\\n scores[bins >= (max_capacity - penalty_threshold)] *= 0.9\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with an increased penalty for bins that are close to full.\\n\\nNew Code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.log(1 + bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\nNew Algorithm Description: \\nThe new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size squared, the cube root of the bin indices, a penalty factor for bins with maximum capacity cubed, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity squared, and an additional factor that encourages the utilization of bins with lower rest capacities through a logarithmic function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins**2 / (item**2 + 1e-6) + np.cbrt(np.arange(len(bins)) + 1)\\n scores += 50 * (bins == item)**3\\n scores += np.log(np.log(bins + 1)) / 10\\n scores *= (0.8 ** (np.cumsum(bins**2) / bins.max()**2)) * 10\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, penalizes bins that are close to full, and finally returns the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and penalizes bins that are close to full based on a sigmoid function.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size combined with a penalty factor, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency in the scoring process.\\n\\nHere is the implementation of the new algorithm as a Python function named \\\"score\\\":\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item) - 10 * (bins == item)\\n scores += 0.3 * (1 - bins / item)\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = 2 * np.log(bins / (item + 1)) + 10 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1))\\n scores *= (0.9 ** (np.cumsum(bins) / max_bin_cap)) * 5\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.log(1 + bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is designed to assign higher scores to bins that are closer in capacity to the size of the item, and lower scores to bins that are significantly larger. The main steps of the algorithm are as follows:\\n\\n1. Calculate the maximum capacity of the bins.\\n2. Compute the score for each bin using a formula involving the bins and the item size.\\n3. Adjust the scores for bins that are larger than the item size.\\n4. Update the scores based on the differences between consecutive elements.\\n5. Return the resulting scores.\\n\\nHere is the implementation of the new algorithm as a function named \\\"score\\\" in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate a score for a given item based on its comparison with a list of bins, adjust the scores for bins greater than the item, and update the scores based on differences between consecutive elements.\\n\\nNew Algorithm Description: The new algorithm calculates the score for a given item based on a modified formula involving the bins and the item, adjusts the scores for bins greater than the item, penalizes bins that are close to full using an exponential decay function, and updates the scores based on the differences between consecutive elements.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.exp(-bins / max_bin_cap) / (item**2) * (bins - max_bin_cap)**2 + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities through a logarithmic function.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += np.log(np.log(bins + 1)) / 10\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins))**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1].copy()\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: \\nThe provided algorithms assign scores to each bin based on a comparison with the item size, considering the rest capacities of the bins. The goal is to minimize the number of used bins.\\n\\nNew algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.log(bins / (item + 1e-6)) + 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / max_bin_cap)) * 4\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a decay factor. Bins with a higher rest capacity and a lower index will be given higher scores, and the scores will decay for bins with larger capacities.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.8\\n\\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size and the index of the bin. Bins with a higher rest capacity and a lower index will be given higher scores, while bins with maximum capacity will be penalized to promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.9\\n \\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor. The penalty factor will penalize bins with larger capacities to promote utilization of bins with lower rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.7\\n \\n scores = ratios + weights - penalty_factor * bins\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms calculate scores for each bin based on the rest capacity of the bin compared to the size of the current item.\\n\\nNew Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with a penalty for bins with maximum capacity and a reward for bins with lower indices, by subtracting a weighted value from the scores and adding a weighted value based on the inverse of the indices, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n inverse_indices = 1 / (weights + 1)\\n decay_factor = 0.9\\n \\n scores = ratios - weights + inverse_indices\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, but prioritize bins with a higher rest capacity and a lower index, by subtracting a weighted value from the scores. The final scores will be multiplied by an exponential decay factor to penalize bins with maximum capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n decay_factor = 0.85\\n \\n scores = ratios - 2 * np.arange(len(bins))\\n scores *= decay_factor ** (ratios / np.max(bins))\\n\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n decay_factor = 0.9\\n \\n scores = ratios - 2 * np.arange(len(bins))\\n scores *= decay_factor\\n\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bin, a penalty for bins with maximum capacity, and the ratio between bin capacity and the item size, while also considering a constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item + (bins / item) * 0.5\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the rest capacity, the index of the bin, and the cumulative sum of the rest capacities. Higher scores are assigned to bins with higher rest capacity, lower index, and larger cumulative sum.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones(len(bins)) * (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a higher index will be prioritized by adding a weighted value to the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities, then the scores will be divided by the index of the bins added to the maximum capacity to further penalize bins with higher indices.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = -1 * np.arange(len(bins))\\n decay_factor = 0.8\\n \\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n scores /= (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities, then the scores will be divided by the index of the bins added to the maximum capacity to further penalize bins with higher indices.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins / bins.max())\\n scores /= (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of the item size to each bin's rest capacity, but prioritizes bins with a higher index, and returns a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n ratios = item / bins[i]\\n scores[i] = ratios * (1 / (len(bins) - i))\\n return scores\",\n \"objective\": 0.04256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on a combination of the rest capacity, the index, and the cumulative sum of the rest capacities, with higher scores assigned to bins with lower rest capacity, higher index, and larger cumulative sum.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n index = np.arange(n)\\n cumsum = np.cumsum(bins)\\n scores = (bins * (bins != np.max(bins))) + (2 * (n - 1 - index)) + cumsum\\n return scores\",\n \"objective\": 0.04266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms calculate scores for each bin based on the rest capacity of the bin compared to the size of the current item.\\n\\nNew Algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins while also considering the ratio between bin capacity and the item size, and applying randomization to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n random_nums = np.random.rand(bins.shape[0])\\n ratios = bins / item\\n scores = (max_capacity - bins) + (bins == max_capacity) * item + ratios * random_nums\\n return scores\",\n \"objective\": 0.04276,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: \\nThe algorithm calculates the scores for each bin based on their rest capacities and assigns the item to the bin with the maximum score, minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.maximum((bins - item), 1)\\n return scores\",\n \"objective\": 0.04306,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the rest capacity, the index, and the cumulative sum of the rest capacities, with higher scores assigned to bins with higher rest capacity, lower index, and larger cumulative sum.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins * (bins == np.max(bins)) + (2 * np.arange(len(bins))) - np.cumsum(bins)\\n return scores\",\n \"objective\": 0.04336,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full, using a different value for the penalty parameter and a different formula.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - np.max(bins))**2 + (1 / item**4) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty = (bins <= (0.85 * np.max(bins)))\\n scores += 0.05 * penalty * np.max(scores)\\n return scores\",\n \"objective\": 0.00523,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the exponential function of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.exp(-0.1 * (bins / max_bin_cap))\\n return scores\",\n \"objective\": 0.00543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nMain Steps:\\n1. Determine the maximum capacity of the bins by finding the maximum value in the 'bins' array.\\n2. Compute the initial score for each bin using the provided formula: (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2.\\n3. Adjust the scores for bins greater than the item by setting their scores to the negative of their original scores.\\n4. Update the scores based on the differences between consecutive elements by subtracting each score from the previous score.\\n5. Add a penalty to the scores for bins that are close to full by multiplying the scores by a penalty factor (e.g., 0.9) if the bin capacity is within a certain threshold (e.g., 10% of the maximum capacity).\\n6. Return the resulting scores as a Numpy array.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = (1 / item**2) * (bins - max_capacity)**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n penalty_threshold = 0.1 * max_capacity\\n scores[bins >= (max_capacity - penalty_threshold)] *= 0.9\\n return scores\",\n \"objective\": 0.00573,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / item**2) * (bins - max(bins))**2 + (1 / item**3) * bins**2\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00584,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with an increased penalty for bins that are close to full.\\n\\nNew Code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item) + bins / (item)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * bins / max_bin_cap\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"```\\nNew Algorithm Description: \\nThe new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size squared, the cube root of the bin indices, a penalty factor for bins with maximum capacity cubed, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity squared, and an additional factor that encourages the utilization of bins with lower rest capacities through a logarithmic function.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins**2 / (item**2 + 1e-6) + np.cbrt(np.arange(len(bins)) + 1)\\n scores += 50 * (bins == item)**3\\n scores += np.log(np.log(bins + 1)) / 10\\n scores *= (0.8 ** (np.cumsum(bins**2) / bins.max()**2)) * 10\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, penalizes bins that are close to full, and finally returns the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.2 * np.exp(-0.1 * bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - np.max(bins))**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / 100)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates the score for a given item based on a modified formula involving the bins and the item, adjusts the scores for bins greater than the item, penalizes bins that are close to full using an inverse exponential decay function, and updates the scores based on the differences between consecutive elements.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.exp(-(bins - item) / max_bin_cap) / (item**2) * (bins - max_bin_cap)**2 + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, and penalizes bins that are close to full based on a sigmoid function.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 1 / (1 + np.exp(-bins / max_bin_cap)) - 0.5\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size combined with a penalty factor, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency in the scoring process.\\n\\nHere is the implementation of the new algorithm as a Python function named \\\"score\\\":\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item + np.log(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item) - 10 * (bins == item)\\n scores += 0.3 * (1 - bins / item)\\n scores *= (0.95 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = 2 * np.log(bins / (item + 1)) + 10 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1))\\n scores *= (0.9 ** (np.cumsum(bins) / max_bin_cap)) * 5\\n scores /= np.sum(scores)\\n \\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nNew Algorithm Description: The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on the logarithm of the differences between consecutive elements, and finally returning the resulting scores with a reduced penalty for bins that are close to full.\\n\\nNew Code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2) + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * np.log(1 + bins / max_bin_cap)\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to bins based on a modified formula involving the item and the bins, adjusts the scores for bins greater than the item, updates the scores based on differences between consecutive elements, penalizes bins that are close to full, and finally returns the resulting scores.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = (bins - max_bin_cap)**2 / (item**2)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms calculate a score for a given item based on its comparison with a list of bins, adjust the scores for bins greater than the item, and update the scores based on differences between consecutive elements.\\n\\nNew Algorithm Description: The new algorithm calculates the score for a given item based on a modified formula involving the bins and the item, adjusts the scores for bins greater than the item, penalizes bins that are close to full using an exponential decay function, and updates the scores based on the differences between consecutive elements.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.exp(-bins / max_bin_cap) / (item**2) * (bins - max_bin_cap)**2 + bins**2 / (item**3)\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, and an additional factor that encourages the utilization of bins with lower rest capacities through a logarithmic function.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += np.log(np.log(bins + 1)) / 10\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a modified formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - max(bins))**2 / item**2 + bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1].copy()\\n penalty = (bins <= (0.8 * max(bins))).astype(int)\\n scores += 0.05 * penalty * max(scores)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: \\nThe provided algorithms assign scores to each bin based on a comparison with the item size, considering the rest capacities of the bins. The goal is to minimize the number of used bins.\\n\\nNew algorithm description: \\nThe new algorithm assigns a score for each bin based on a modified formula that incorporates the logarithm of the ratio between the rest capacity of the bin and the item size, penalizes bins with maximum capacity squared, rewards bins with rest capacity equal to the item size, encourages the utilization of bins with lower rest capacities, and introduces a factor based on the cumulative sum of the rest capacities divided by the maximum capacity, adjusted by specific values, and multiplied by a normalization factor to maintain self-consistency.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = np.max(bins)\\n scores = np.log(bins / (item + 1e-6)) + 20 * (bins == item)\\n scores += 0.2 * (1 - bins / (item + 1e-6))\\n scores *= (0.95 ** (np.cumsum(bins) / max_bin_cap)) * 4\\n scores /= np.sum(scores)\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (item + 1e-6) + np.sqrt(np.arange(len(bins)) + 1)\\n scores += 20 * (bins == item)\\n scores += 0.5 * (1 - bins / (item + 1e-6))\\n scores *= (0.9 ** (np.cumsum(bins) / bins.max())) * 4\\n scores /= scores.sum()\\n\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with lower indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n decay_factor = 0.9\\n\\n scores = ratios - weights - 1 / counter\\n scores *= decay_factor ** (bins / bins.max())\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a decay factor. Bins with a higher rest capacity and a lower index will be given higher scores, and the scores will decay for bins with larger capacities.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.8\\n\\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the rest capacity, the bin's index, and the cube of the bin's rest capacity divided by the square of the item size. Higher scores are assigned to bins with higher rest capacity, lower index, and larger cube values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.arange(len(bins)) - (bins**3/(item**2))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size and the index of the bin. Bins with a higher rest capacity and a lower index will be given higher scores, while bins with maximum capacity will be penalized to promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.9\\n \\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the following steps:\\n1. Normalize the rest capacities of the bins by dividing each bin's capacity by the maximum capacity.\\n2. Calculate the ratios of the normalized capacities to the item size and store them in a variable called \\\"ratios\\\".\\n3. Create a weight array using the formula 2 * (n - 1 - index), where n is the total number of bins and index is the index of each bin.\\n4. Calculate the scores by adding the ratios to the weights.\\n5. Multiply the scores by a decay factor raised to the power of the normalized capacities, to penalize bins with larger capacities.\\n6. Return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n normalized_capacities = bins / np.max(bins)\\n ratios = normalized_capacities / item\\n weights = 2 * (n - 1 - np.arange(n))\\n decay_factor = 0.95\\n \\n scores = ratios + weights\\n scores *= decay_factor ** normalized_capacities\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the rest capacity, the index of the bin, and the square of the bin's rest capacity divided by the item size. Higher scores are assigned to bins with higher rest capacity, lower index, and larger square values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.arange(len(bins)) - (bins**2/item)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor. The penalty factor will penalize bins with larger capacities to promote utilization of bins with lower rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.7\\n \\n scores = ratios + weights - penalty_factor * bins\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms calculate scores for each bin based on the rest capacity of the bin compared to the size of the current item.\\n\\nNew Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with a penalty for bins with maximum capacity and a reward for bins with lower indices, by subtracting a weighted value from the scores and adding a weighted value based on the inverse of the indices, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n inverse_indices = 1 / (weights + 1)\\n decay_factor = 0.9\\n \\n scores = ratios - weights + inverse_indices\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a higher index will be prioritized by adding a weighted value to the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities, then the scores will be divided by the index of the bins added to the maximum capacity to further penalize bins with higher indices.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n weights = -1 * np.arange(len(bins))\\n \\n scores = ratios + weights\\n scores /= (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, but prioritize bins with a higher rest capacity and a lower index, by subtracting a weighted value from the scores. The final scores will be multiplied by an exponential decay factor to penalize bins with maximum capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the following steps:\\n1. Normalize the rest capacities of the bins by dividing each bin's capacity by the maximum capacity.\\n2. Calculate the ratios of the normalized capacities to the item size and store them in a variable called \\\"ratios\\\".\\n3. Create a weight array using the formula 2 * (n - 1 - index), where n is the total number of bins and index is the index of each bin.\\n4. Calculate the scores by adding the ratios to the weights.\\n5. Multiply the scores by a decay factor raised to the power of the normalized capacities, to penalize bins with larger capacities.\\n6. Return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n normalized_capacities = bins / np.max(bins)\\n ratios = normalized_capacities / item\\n weight = 2\\n decay_factor = 0.95\\n \\n scores = ratios + weight\\n scores *= decay_factor ** normalized_capacities\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n decay_factor = 0.85\\n \\n scores = ratios - 2 * np.arange(len(bins))\\n scores *= decay_factor ** (ratios / np.max(bins))\\n\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the sum of the inverse of the ratio of the item size to each bin's rest capacity and the index of the bin, to prioritize bins with lower rest capacities and lower indices for assignment, and returns a Numpy array of scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins, dtype=float)\\n for i in range(len(bins)):\\n ratios = item / bins[i]\\n scores[i] = 1 / ratios + i\\n return scores\",\n \"objective\": 0.04196,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, but prioritize bins with a higher rest capacity and a lower index, by subtracting a weighted value from the scores. The final scores will be multiplied by an exponential decay factor to penalize bins with maximum capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratio = bins / item\\n scores = ratio - 2 * np.arange(len(bins))\\n \\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the remaining capacity of the bin, a penalty for bins with maximum capacity, and the ratio between bin capacity and the item size, while also considering a constant factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.max(bins) - bins) + (bins == np.max(bins)) * item + (bins / item) * 0.5\\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the rest capacity, the index of the bin, and the cumulative sum of the rest capacities. Higher scores are assigned to bins with higher rest capacity, lower index, and larger cumulative sum.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.ones(len(bins)) * (item + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the inverse of the indices, and a penalty factor for bins with maximum capacity, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with lower indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.9 ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on various factors such as rest capacity, index, ratio of rest capacity to item size, and penalty for maximum capacity.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the combination of the rest capacity, the index of the bin, the square of the bin's rest capacity divided by the item size, and a penalty for maximum capacity to minimize the number of used bins and promote utilization of bins with lower rest capacities, while avoiding the random component and maintaining self-consistency.\\n\\nHere's the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n indices = np.arange(len(bins))\\n ratios = bins / item\\n penalties = (bins == max_capacity) * item\\n \\n scores = bins + indices - (bins**2/item) + penalties\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a decay factor. Bins with a higher rest capacity and a lower index will be given higher scores, and the scores will decay for bins with larger capacities.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.8\\n\\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the rest capacity, the bin's index, and the cube of the bin's rest capacity divided by the square of the item size. Higher scores are assigned to bins with higher rest capacity, lower index, and larger cube values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.arange(len(bins)) - (bins**3/(item**2))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size and the index of the bin. Bins with a higher rest capacity and a lower index will be given higher scores, while bins with maximum capacity will be penalized to promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.9\\n \\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm is based on the original algorithm, but with some modifications. The main steps are as follows:\\n\\n1. Normalize the rest capacities of the bins by dividing each bin's capacity by the maximum capacity.\\n2. Calculate the ratios of the normalized capacities to the item size and store them in the variable \\\"ratios\\\".\\n3. Create a weight array using the formula 2 * (n - index), where n is the total number of bins and index is the index of each bin.\\n4. Calculate the scores by adding the ratios to the weights.\\n5. Multiply the scores by a decay factor raised to the power of the normalized capacities, to penalize bins with larger capacities.\\n6. Return the scores as a Numpy array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n normalized_capacities = bins / np.max(bins)\\n ratios = normalized_capacities / item\\n weight = 2 * (n - np.arange(n))\\n decay_factor = 0.95\\n \\n scores = ratios + weight\\n scores *= decay_factor ** normalized_capacities\\n\\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"description = \\\"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.8.\\\"\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.8\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the rest capacity, the index of the bin, and the square of the bin's rest capacity divided by the item size. Higher scores are assigned to bins with higher rest capacity, lower index, and larger square values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.arange(len(bins)) - (bins**2/item)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.9\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor. The penalty factor will penalize bins with larger capacities to promote utilization of bins with lower rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.7\\n \\n scores = ratios + weights - penalty_factor * bins\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: All of the provided algorithms calculate scores for each bin based on the rest capacity of the bin compared to the size of the current item.\\n\\nNew Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with a penalty for bins with maximum capacity and a reward for bins with lower indices, by subtracting a weighted value from the scores and adding a weighted value based on the inverse of the indices, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n inverse_indices = 1 / (weights + 1)\\n decay_factor = 0.9\\n \\n scores = ratios - weights + inverse_indices\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a higher index will be prioritized by adding a weighted value to the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities, then the scores will be divided by the index of the bins added to the maximum capacity to further penalize bins with higher indices.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n weights = -1 * np.arange(len(bins))\\n \\n scores = ratios + weights\\n scores /= (np.arange(len(bins)) + 1)\\n\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, but prioritize bins with a higher rest capacity and a lower index, by subtracting a weighted value from the scores. The final scores will be multiplied by an exponential decay factor to penalize bins with maximum capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04155,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the following steps:\\n1. Normalize the rest capacities of the bins by dividing each bin's capacity by the maximum capacity.\\n2. Calculate the ratios of the normalized capacities to the item size and store them in a variable called \\\"ratios\\\".\\n3. Create a weight array using the formula 2 * (n - 1 - index), where n is the total number of bins and index is the index of each bin.\\n4. Calculate the scores by adding the ratios to the weights.\\n5. Multiply the scores by a decay factor raised to the power of the normalized capacities, to penalize bins with larger capacities.\\n6. Return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n normalized_capacities = bins / np.max(bins)\\n ratios = normalized_capacities / item\\n weight = 2\\n decay_factor = 0.95\\n \\n scores = ratios + weight\\n scores *= decay_factor ** normalized_capacities\\n\\n return scores\",\n \"objective\": 0.04165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = 2 * np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size. Bins with a higher rest capacity and a lower index will be prioritized by subtracting a weighted value from the scores. The final scores will be multiplied by a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, to penalize bins with maximum capacity and promote utilization of bins with lower rest capacities.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n decay_factor = 0.85\\n \\n scores = ratios - 2 * np.arange(len(bins))\\n scores *= decay_factor ** (ratios / np.max(bins))\\n\\n return scores\",\n \"objective\": 0.04186,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with higher indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.8 ** ((bins / bins.max()) ** 2))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the inverse of the indices, and a penalty factor for bins with maximum capacity, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with lower indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.9 ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.8. Additionally, the algorithm will assign a bonus score of 10 to bins with rest capacity equal to the item size, to encourage using these bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.8\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n scores += 10 * (bins == item)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with higher indices and a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - indices\\n scores *= (decay_factor ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on various factors such as rest capacity, index, ratio of rest capacity to item size, and penalty for maximum capacity.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the combination of the rest capacity, the index of the bin, the square of the bin's rest capacity divided by the item size, and a penalty for maximum capacity to minimize the number of used bins and promote utilization of bins with lower rest capacities, while avoiding the random component and maintaining self-consistency.\\n\\nHere's the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n indices = np.arange(len(bins))\\n ratios = bins / item\\n penalties = (bins == max_capacity) * item\\n \\n scores = bins + indices - (bins**2/item) + penalties\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a decay factor. Bins with a higher rest capacity and a lower index will be given higher scores, and the scores will decay for bins with larger capacities.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.8\\n\\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the rest capacity, the bin's index, and the cube of the bin's rest capacity divided by the square of the item size. Higher scores are assigned to bins with higher rest capacity, lower index, and larger cube values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.arange(len(bins)) - (bins**3/(item**2))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size and the index of the bin. Bins with a higher rest capacity and a lower index will be given higher scores, while bins with maximum capacity will be penalized to promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.9\\n \\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse of the rest capacity multiplied by the item size, with additional adjustments based on the bin's index and a decay factor raised to the power of the rest capacity normalized by the maximum capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n normalized_capacities = bins / np.max(bins)\\n indices = np.arange(n)\\n decay_factor = 0.95\\n \\n scores = item / bins\\n scores += indices\\n scores *= decay_factor ** normalized_capacities\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor that is adjusted based on the cumulative sum of the rest capacities, with additional penalties for bins with maximum capacity and bins that have not been utilized as frequently as others, promoting utilization of bins with lower rest capacities, lower indices, and higher frequency of utilization. This algorithm aims to balance the utilization of bins while minimizing the number of used bins.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.8 # Adjusted to 0.8 for more significant penalties\\n frequency_penalty = np.cumsum(bins) # Replaced np.arange(1, len(bins) + 1) with cumulative sum of rest capacities\\n\\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n scores -= penalty_factor * (1 / frequency_penalty)\\n\\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"description = \\\"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.8.\\\"\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.8\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the following steps:\\n1. Normalize the rest capacities of the bins by dividing each bin's capacity by the maximum capacity.\\n2. Calculate the ratios of the item size to the normalized capacities and store them in a variable called \\\"ratios\\\".\\n3. Create a weight array using the formula (2 * (n - 1 - index))^2, where n is the total number of bins and index is the index of each bin.\\n4. Calculate the scores by adding the ratios to the weights.\\n5. Multiply the scores by a decay factor raised to the power of the normalized capacities, to penalize bins with larger capacities.\\n6. Return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n normalized_capacities = bins / np.max(bins)\\n ratios = item / normalized_capacities\\n weight = np.square(2 * (n - 1 - np.arange(n)))\\n decay_factor = 0.95\\n \\n scores = ratios + weight\\n scores *= decay_factor ** normalized_capacities\\n\\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a combination of the rest capacity, the index of the bin, and the square of the bin's rest capacity divided by the item size. Higher scores are assigned to bins with higher rest capacity, lower index, and larger square values.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.arange(len(bins)) - (bins**2/item)\\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms calculate scores for each bin based on the ratio of the rest capacity to the item size, the index of the bin, and penalties for bins with maximum capacity.\\n\\nNew algorithm description: The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor that is adjusted based on the cumulative sum of the rest capacities, with additional penalties for bins with maximum capacity and bins that have not been utilized as frequently as others, promoting utilization of bins with lower rest capacities, lower indices, and higher frequency of utilization.\\n\\nNew algorithm code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.9\\n frequency_penalty = np.arange(1, len(bins) + 1)\\n\\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n scores -= penalty_factor * (1 / frequency_penalty)\\n\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.9\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04085,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor. The penalty factor will penalize bins with larger capacities to promote utilization of bins with lower rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.7\\n \\n scores = ratios + weights - penalty_factor * bins\\n\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity, with a penalty for bins with maximum capacity to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) + (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The score function will calculate the scores for each bin based on a combination of the following factors: the ratio of each bin's rest capacity to the item size, the inverse of the indices, and a penalty factor for bins with maximum capacity, while also considering the cumulative sum of the rest capacities, applying an exponential decay factor, and assigning a bonus score of 10 to bins with rest capacity equal to the item size, to encourage using these bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.8\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += 10 * (bins == item)\\n\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.8. Additionally, the algorithm will assign a bonus score of 10 to bins with rest capacity equal to the item size, to encourage using these bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n penalty_factor = 0.8\\n \\n scores = ratios + 1\\n scores -= penalty_factor * (bins == bins.max())\\n scores += 10 * (bins == item)\\n \\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with higher indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities, while also considering the logarithm of the cumulative sum of rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.8 ** ((bins / bins.max()) ** 2))\\n scores *= np.cumsum(bins)\\n scores *= np.log(1 + np.cumsum(bins))\\n\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments based on factors like bin index, decay factor, and cumulative sum of rest capacities.\\n\\nNew algorithm: \\nThe score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with higher indices, and bins that have not been utilized as frequently as others, by subtracting weighted values from the scores, multiplying by a decay factor, adjusting based on the cumulative sum of the rest capacities, and adding a term based on the logarithm of the rest capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n decay_factor = 0.85\\n \\n scores = ratios - weights - 1 / counter\\n scores *= (0.9 ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n scores += np.log(bins)\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with higher indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.8 ** ((bins / bins.max()) ** 2))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the inverse of the indices, and a penalty factor for bins with maximum capacity, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with higher indices and a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n decay_factor = 0.9\\n\\n scores = (ratios - np.arange(len(bins))) * (decay_factor ** ratios) * np.cumsum(ratios)\\n\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with lower indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.9 ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.8. Additionally, the algorithm will assign a bonus score of 10 to bins with rest capacity equal to the item size, to encourage using these bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.8\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n scores += 10 * (bins == item)\\n \\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with higher indices and a decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n decay_factor = 0.9\\n \\n scores = ratios - indices\\n scores *= (decay_factor ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.5. Additionally, the algorithm will assign a bonus score of 15 to bins with rest capacity equal to the item size, to encourage using these bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.5\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n scores += 15 * (bins == item)\\n \\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on various factors such as rest capacity, index, ratio of rest capacity to item size, and penalty for maximum capacity.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the combination of the rest capacity, the index of the bin, the square of the bin's rest capacity divided by the item size, and a penalty for maximum capacity to minimize the number of used bins and promote utilization of bins with lower rest capacities, while avoiding the random component and maintaining self-consistency.\\n\\nHere's the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n indices = np.arange(len(bins))\\n ratios = bins / item\\n penalties = (bins == np.max(bins)) * item\\n\\n scores = bins + indices - (bins**2/item) + penalties\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Calculate the ratio of item size to each bin's rest capacity.\\n2. Calculate the score for each bin based on the ratio and the condition of the rest capacity.\\n3. Return the scores for the bins for assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a decay factor. Bins with a higher rest capacity and a lower index will be given higher scores, and the scores will decay for bins with larger capacities.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.8\\n\\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the rest capacity, the bin's index, and the cube of the bin's rest capacity divided by the square of the item size. Higher scores are assigned to bins with higher rest capacity, lower index, and larger cube values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.arange(len(bins)) - (bins**3/(item**2))\\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size and the index of the bin. Bins with a higher rest capacity and a lower index will be given higher scores, while bins with maximum capacity will be penalized to promote utilization of bins with lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n decay_factor = 0.9\\n \\n scores = ratios + weights\\n scores *= decay_factor ** (bins / bins.max())\\n\\n return scores\",\n \"objective\": 0.04014,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the inverse of the rest capacity multiplied by the item size, with additional adjustments based on the bin's index and a decay factor raised to the power of the rest capacity normalized by the maximum capacity.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n n = len(bins)\\n normalized_capacities = bins / np.max(bins)\\n indices = np.arange(n)\\n decay_factor = 0.95\\n \\n scores = item / bins\\n scores += indices\\n scores *= decay_factor ** normalized_capacities\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on various factors such as rest capacity, index, ratios, weights, and penalties.\\n\\nNew Algorithm: The score function will calculate the scores for each bin based on the sum of the bin's rest capacity divided by the item size and its index, with an additional factor that penalizes bins with maximum capacity to promote utilization of bins with lower rest capacities.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = (bins / item).reshape((-1, 1))\\n indices = np.arange(len(bins)).reshape((-1, 1))\\n penalties = np.where(bins == bins.max(), -0.8, 0)\\n \\n scores = np.sum(np.concatenate((ratios, indices), axis=1), axis=1) + penalties\\n \\n return scores\",\n \"objective\": 0.04035,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"description = \\\"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.8.\\\"\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins), 0, -1)\\n penalty_factor = 0.8\\n \\n scores = ratios + weights\\n scores -= penalty_factor * (bins == bins.max())\\n\\n return scores\",\n \"objective\": 0.04045,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone Idea: The common backbone idea in all the provided algorithms is to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.7\\n bonus_score = 20\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an additional factor that promotes the usage of lower rest capacities, where the penalty factor will be adjusted to 0.7, the bonus score will be increased to 20, and the additional factor will be set to 0.5.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n penalty_factor = 0.7\\n bonus_score = 20\\n additional_factor = 0.5\\n \\n scores = ratios + 1\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n \\n return scores\",\n \"objective\": 0.0167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an additional factor that promotes the usage of lower rest capacities, where the penalty factor will be adjusted to 0.5, the bonus score will be increased to 30, and the additional factor will be set to 0.7 (the formula remains the same).\\n\\nHere's the implementation of the modified algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n penalty_factor = 0.5\\n bonus_score = 30\\n additional_factor = 0.7\\n \\n scores = ratios + 1\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n \\n return scores\",\n \"objective\": 0.02264,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate the scores for each bin based on the ratio between the bin's rest capacity and the item size, and then apply additional factors such as penalties, bonuses, and cumulative sums to adjust the scores.\\n\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the bin indices, penalties for bins with maximum capacity, bonuses for bins with rest capacity equal to the item size, and an additional factor that promotes the usage of lower rest capacities, with adjusted values for the penalty factor, bonus score, and additional factor.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.6\\n bonus_score = 25\\n additional_factor = 0.3\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n \\n return scores\",\n \"objective\": 0.02757,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an additional factor that encourages the utilization of bins with lower rest capacities. The algorithm will also apply a decay factor to the scores based on the cumulative sum of the rest capacities divided by the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n penalty_factor = 0.7\\n bonus_score = 20\\n additional_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.8\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n \\n return scores\",\n \"objective\": 0.02787,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the ratio between each bin's rest capacity and the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a cumulative sum of the rest capacities. The algorithm also applies an exponential decay factor to the scores based on the cumulative sum divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.8\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += 10 * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.02998,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The score function will calculate the scores for each bin based on a combination of the following factors: the ratio of each bin's rest capacity to the item size, the inverse of the indices, and a penalty factor for bins with maximum capacity, while also considering the cumulative sum of the rest capacities, applying an exponential decay factor, and assigning a bonus score of 10 to bins with rest capacity equal to the item size, to encourage using these bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.8\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += 10 * (bins == item)\\n\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional adjustments based on the bin indices, rest capacity utilization, the cumulative sum of rest capacities, and a penalty factor for bins with maximum capacity, while also applying a linear decay factor and adding a bonus score of 5 for bins with rest capacity equal to the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios - indices\\n scores *= decay_factor * (cumulative_sum / bins.max())\\n scores += 5 * (bins == item)\\n \\n return scores\",\n \"objective\": 0.03028,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, penalties for bins with maximum capacity, and bonuses for bins with rest capacity equal to the item size, while also applying a decay factor to the scores using the cumulative sum of the rest capacities divided by the maximum capacity and adjusting the penalty factor, bonus score, and additional factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n penalty_factor = 0.5\\n bonus_score = 30\\n additional_factor = 0.7\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n \\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the ratio between each bin's rest capacity and the item size, the square root of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a cumulative sum of the rest capacities. The algorithm also applies a logarithmic decay factor to the scores based on the cumulative sum divided by the maximum capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n sqrt_indices = np.sqrt(np.arange(len(bins)) + 1)\\n penalty_factor = 0.6\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = np.log(cumulative_sum) / np.log(bins.max())\\n \\n scores = ratios + sqrt_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += 10 * (bins == item)\\n scores *= decay_factor\\n\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional adjustments based on the bin indices, rest capacity utilization, the cumulative sum of rest capacities, and a penalty factor for bins with maximum capacity, while also applying a linear decay factor and adding a bonus score of 5 for bins with rest capacity equal to the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n indices = np.arange(len(bins))\\n cumulative_sum = np.cumsum(bins)\\n penalty_factor = 0.8\\n decay_factor = 0.9\\n \\n scores = ratios - indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor * (cumulative_sum / bins.max())\\n scores += 5 * (bins == item)\\n \\n return scores\",\n \"objective\": 0.0332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the index of the bin, and a penalty factor for bins with maximum capacity to promote utilization of bins with lower rest capacities, where the penalty factor will be adjusted to 0.8. Additionally, the algorithm will assign a bonus score of 10 to bins with rest capacity equal to the item size, to encourage using these bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n penalty_factor = 0.8\\n \\n scores = ratios + 1\\n scores -= penalty_factor * (bins == bins.max())\\n scores += 10 * (bins == item)\\n \\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an additional factor that promotes the usage of lower rest capacities, where the penalty factor will be adjusted to 0.5, the bonus score will be increased to 30, and the additional factor will be set to 0.7 (the formula remains the same) while considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n penalty_factor = 0.5\\n bonus_score = 30\\n additional_factor = 0.7\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + 1\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n \\n return scores\",\n \"objective\": 0.03481,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the following factors: the square of the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, an additional factor that promotes the usage of lower rest capacities, and a term that increases the scores for bins with rest capacity equal to the item size, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.65\\n additional_factor = 0.8\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios ** 2 + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += additional_factor * (1 - ratios)\\n scores += 10 * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.03582,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with higher indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities, while also considering the logarithm of the cumulative sum of rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.8 ** ((bins / bins.max()) ** 2))\\n scores *= np.cumsum(bins)\\n scores *= np.log(1 + np.cumsum(bins))\\n\\n return scores\",\n \"objective\": 0.03733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments based on factors like bin index, decay factor, and cumulative sum of rest capacities.\\n\\nNew algorithm: \\nThe score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with higher indices, and bins that have not been utilized as frequently as others, by subtracting weighted values from the scores, multiplying by a decay factor, adjusting based on the cumulative sum of the rest capacities, and adding a term based on the logarithm of the rest capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n decay_factor = 0.85\\n \\n scores = ratios - weights - 1 / counter\\n scores *= (0.9 ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n scores += np.log(bins)\\n\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional adjustments based on factors like bin index, decay factor, and cumulative sum of rest capacities, and penalty for bins that have not been utilized as frequently as others.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n decay_factor = 0.85\\n \\n scores = ratios - weights - 1 / counter\\n scores *= (0.9 ** (bins / bins.max()))\\n scores *= np.cumsum(bins)\\n scores += np.log(bins)\\n scores -= np.log(counter)\\n\\n return scores\",\n \"objective\": 0.03783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional penalties for bins with maximum capacity, bins with higher indices, and bins that have not been utilized as frequently as others, by subtracting a weighted value from the scores, multiplying by a decay factor, and adjusting the scores based on the cumulative sum of the rest capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n weights = np.arange(len(bins))\\n counter = np.arange(1, len(bins) + 1)\\n\\n scores = ratios - weights - 1 / counter\\n scores *= (0.8 ** ((bins / bins.max()) ** 2))\\n scores *= np.cumsum(bins)\\n\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, the inverse of the indices, and a penalty factor for bins with maximum capacity, while also considering the cumulative sum of the rest capacities and applying an exponential decay factor to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n \\n scores = ratios + inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.03803,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm will calculate the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the cumulative sum of rest capacities, penalties for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's rest capacity to the maximum capacity, and an adjustment based on the cumulative sum of the rest capacities divided by the maximum capacity, while also considering a penalty factor for bins with rest capacity significantly larger than the item size, obtained by applying a square root function to the ratio of the two.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n logarithm_indices = np.log(np.arange(1, len(bins) + 1))\\n cumulative_sum = np.cumsum(bins)\\n max_capacity = bins.max()\\n max_capacity_penalty = 0.5 # Penalty for bins with maximum capacity\\n bonus_score = 8 # Bonus score for bins with rest capacity equal to the item size\\n decay_factor = 0.8 # Exponential decay factor\\n\\n penalty_factor = np.sqrt(ratios) # Penalty for bins with rest capacity significantly larger than item size\\n \\n scores = ratios * logarithm_indices\\n scores -= max_capacity_penalty * (bins == max_capacity)\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins > item)\\n scores *= decay_factor ** (cumulative_sum / max_capacity)\\n\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm will calculate the scores for each bin based on a combination of the logarithm of the bin indices, the ratio of each bin's rest capacity to the item size, and the cumulative sum of rest capacities, while considering penalty factors for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor that promotes the usage of lower rest capacities. Additionally, the algorithm will incorporate a penalty for bins with rest capacity significantly larger than the item size, by applying a square root function to the ratio of the two.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 12\\n \\n ratio = bins / (item + epsilon)\\n penalty_factor = np.sqrt(ratio) # Adjusted ratio penalty\\n \\n scores = indices * ratio\\n scores -= 0.75 * (bins == bins.max())\\n scores -= 0.1 * penalty_factor * (bins > item) # Penalty for bins with rest capacity significantly larger than item size\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with adjustments based on factors like bin index, penalties for maximum capacity, bonuses for rest capacity equal to the item size, and additional factors such as logarithm of indices, cumulative sum of rest capacities, and decay factors.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional adjustments based on the bin index, rest capacity utilization, the cumulative sum of rest capacities, a penalty factor for bins with maximum capacity, logarithm of the bin indices, decay factor, and bonus score for bins with rest capacity equal to the item size, while also considering the inverse of the indices, exponential decay factor, and a factor that promotes the usage of lower rest capacities.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n bonus_score = 10\\n logarithm_indices = np.log(np.arange(1, len(bins) + 1))\\n additional_factor = 0.5\\n \\n scores = ratios\\n scores -= inverse_indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n scores += logarithm_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n penalty_factor = 0.6\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n \\n scores = bins / (item + epsilon) + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments based on factors such as bin index, cumulative sum of capacities, penalty factors, logarithmic terms, and bonus scores.\\n\\nNew Algorithm Description: The new algorithm will calculate the scores for each bin based on a combination of the logarithm of the bin indices, the ratio of each bin's rest capacity to the item size, and the cumulative sum of rest capacities, while considering penalty factors for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor that promotes the usage of lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 12\\n \\n scores = indices * bins / (item + epsilon)\\n scores -= 0.75 * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The score function calculates the scores for each bin based on a combination of the bin's rest capacity, the item size, and various penalty and bonus factors, using mathematical functions such as logarithm, exponentiation, and arithmetic operations.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n bin_indices = np.arange(1, len(bins) + 1)\\n max_capacity_penalty = 0.3\\n bonus_score = 10\\n additional_factor = 0.2\\n decay_factor = 0.9\\n \\n scores = (bins / (item + epsilon)) * np.log(bin_indices)\\n scores -= max_capacity_penalty * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on a combination of the bin's rest capacity to the item size ratio, a penalty factor for bins with maximum capacity, and a logarithmic term based on the bin indices. It will also consider the cumulative sum of the rest capacities, applying a decay factor, and assign a bonus score for bins with rest capacity equal to the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n penalty_factor = 0.5\\n logarithm_indices = 0.5 * np.log(np.arange(1, len(bins) + 1))\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.95\\n bonus_score = 10\\n\\n scores = ratios\\n scores -= penalty_factor * (bins == bins.max())\\n scores += logarithm_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone Idea: The common backbone idea in all the provided algorithms is to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.7\\n bonus_score = 20\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with higher indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities divided by the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n bonus_score = 15\\n decay_factor = 0.85\\n cumulative_sum = np.cumsum(bins)\\n max_capacity = bins.max()\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == max_capacity)\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / max_capacity)\\n scores *= (cumulative_sum / max_capacity)\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n bonus_score = 15\\n decay_factor = 0.85\\n cumulative_sum = np.cumsum(bins)\\n max_capacity = bins.max()\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == max_capacity)\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / max_capacity)\\n scores *= (cumulative_sum / max_capacity)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional adjustments based on the bin index, rest capacity utilization, the cumulative sum of rest capacities, a penalty factor for bins with maximum capacity, logarithm of the bin indices, decay factor, and bonus score for bins with rest capacity equal to the item size, while also considering the inverse of the indices, exponential decay factor, and introducing a factor that promotes the usage of bins with lower indices and higher rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.8\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n bonus_score = 10\\n logarithm_indices = np.log(np.arange(1, len(bins) + 1))\\n additional_factor = 0.5\\n promotion_factor = np.arange(len(bins))[::-1] + 1\\n \\n scores = ratios\\n scores -= inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n scores += logarithm_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores *= promotion_factor\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the exponential decay factor raised to the power of the cumulative sum of the rest capacities, a bonus score for bins with rest capacities equal to the item size, and a penalty factor for bins with maximum capacity, while also applying additional adjustments based on the bin indices and the ratio of each bin's rest capacity to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 10\\n penalty_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins == bins.max())\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the score for each bin based on the ratio of each bin's remaining capacity to the item size, with an additional bonus score for bins with rest capacity equal to the item size, an inverse bonus score for bins with higher indices, and a decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n \\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n bonus_score = 20\\n inverse_bonus_score = -10\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios\\n scores += bonus_score * (bins == item)\\n scores += inverse_bonus_score * inverse_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm calculates the scores for each bin based on a customized combination of the ratio between each bin's rest capacity and the item size, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a cumulative sum of the rest capacities. The algorithm also applies an exponential decay factor to the scores based on the cumulative sum divided by the maximum capacity, but with a modified decay factor that decreases the decay rate over time.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 100 # Simplified scaling factor for ratios\\n\\n ratios = bins / (item * scaling_factor)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = np.exp(-0.05 * (cumulative_sum / bins.max())) # Simplified decay factor\\n \\n scores = ratios\\n scores += 10 * (bins == item)\\n scores *= decay_factor\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with an increased penalty factor for bins with lower indices, a larger bonus score for bins with rest capacity equal to the item size, and a higher exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 1.2 # Increased penalty factor\\n bonus_score = 30 # Increased bonus score\\n decay_factor = 0.95 # Higher decay factor\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The score function will calculate the scores for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 25 # Changed bonus score to 25\\n decay_factor = 0.85 # Changed decay factor to 0.85\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The score function will calculate the scores for each bin based on a combination of the following factors: the ratio of each bin's rest capacity to the item size, the logarithm of the indices, a penalty factor for bins with maximum capacity, while also considering the cumulative sum of the rest capacities, applying an exponential decay factor, and assigning a bonus score of 5 to bins with rest capacity equal to the item size.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n log_indices = np.log10(np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.95\\n \\n scores = ratios + log_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += 5 * (bins == item)\\n\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with higher indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.75 # Changed penalty factor to 0.75\\n bonus_score = 20 # Changed bonus score to 20\\n decay_factor = 0.9 # Changed decay factor to 0.9\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (ratios * (bins == bins.max()))\\n\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n bonus_score = 25 # Changed bonus score to 25\\n decay_factor = 0.85 # Changed decay factor to 0.85\\n \\n scores = ratios - inverse_indices\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (ratios * (bins == bins.max()))\\n\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 25 # Changed bonus score to 25\\n decay_factor = 0.85 # Changed decay factor to 0.85\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (ratios * (bins == bins.max()))\\n\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Ablation_EoH_UseExpertHeuristic/Run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 2 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.6 # Changed penalty factor to 0.6\\n bonus_score = 20 # Changed bonus score to 20\\n decay_factor = 0.9 # Changed decay factor to 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00594,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: This algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores with an added penalty for bins that are close to full.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n scores = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n scores += bins**2 / item**3\\n scores[bins > item] = -scores[bins > item]\\n scores[1:] -= scores[:-1]\\n scores += 0.1 * (bins / max_bin_cap)**2\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices plus one, a penalty factor for bins with maximum capacity squared, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor, multiplied by a normalization factor based on the sum of the scores to maintain self-consistency. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(len(bins)) + 1)\\n penalty_factor = 1 # Adjusted penalty_factor\\n bonus_score = 20 # Adjusted bonus_score\\n additional_factor = 0.5 # Adjusted additional_factor\\n decay_factor = 0.9 # Adjusted decay_factor\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= (decay_factor ** (np.cumsum(bins) / bins.max())) * (penalty_factor ** 2)\\n scores /= scores.sum() # Normalization factor\\n\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.zeros(len(bins)) # Simplified component: Initialize indices as zeros\\n penalty_factor = 0 # Simplified component: Set penalty_factor to 0\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm will calculate the scores for each bin based on a combination of the logarithm of the bin indices, the ratio of each bin's rest capacity to the item size, and the cumulative sum of rest capacities, while considering penalty factors for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor that promotes the usage of lower rest capacities. Additionally, the algorithm will incorporate a penalty for bins with rest capacity significantly larger than the item size, by applying a square root function to the ratio of the two.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 12\\n \\n ratio = bins / (item + epsilon)\\n penalty_factor = np.sqrt(ratio) # Adjusted ratio penalty\\n \\n scores = indices * ratio\\n scores -= 0.75 * (bins == bins.max())\\n scores -= 0.1 * penalty_factor * (bins > item) # Penalty for bins with rest capacity significantly larger than item size\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with adjustments based on factors like bin index, penalties for maximum capacity, bonuses for rest capacity equal to the item size, and additional factors such as logarithm of indices, cumulative sum of rest capacities, and decay factors.\\n\\nNew algorithm: The score function will calculate the scores for each bin based on the ratio of each bin's rest capacity to the item size, with additional adjustments based on the bin index, rest capacity utilization, the cumulative sum of rest capacities, a penalty factor for bins with maximum capacity, logarithm of the bin indices, decay factor, and bonus score for bins with rest capacity equal to the item size, while also considering the inverse of the indices, exponential decay factor, and a factor that promotes the usage of lower rest capacities.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = 0.9\\n bonus_score = 10\\n logarithm_indices = np.log(np.arange(1, len(bins) + 1))\\n additional_factor = 0.5\\n \\n scores = ratios\\n scores -= inverse_indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - ratios)\\n scores += logarithm_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n penalty_factor = 0.6\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n \\n scores = bins / (item + epsilon) + indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThis algorithm calculates a score for a given item based on its comparison with a list of bins by first determining the maximum capacity of the bins, then computing a score using a formula involving the bins and the item, adjusting the scores for bins greater than the item, updating the scores based on differences between consecutive elements, and finally returning the resulting scores.\\n\",\n \"code\": \"import numpy as np\\ndef score(item, bins):\\n max_bin_cap = max(bins)\\n score = (bins - max_bin_cap)**2 / item + bins**2 / (item**2)\\n score += bins**2 / item**3\\n score[bins > item] = -score[bins > item]\\n score[1:] -= score[:-1]\\n return score\",\n \"objective\": 0.0068,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments based on factors such as bin index, cumulative sum of capacities, penalty factors, logarithmic terms, and bonus scores.\\n\\nNew Algorithm Description: The new algorithm will calculate the scores for each bin based on a combination of the logarithm of the bin indices, the ratio of each bin's rest capacity to the item size, and the cumulative sum of rest capacities, while considering penalty factors for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor that promotes the usage of lower rest capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 12\\n \\n scores = indices * bins / (item + epsilon)\\n scores -= 0.75 * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n \\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on a combination of the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the cumulative sum of rest capacities raised to a power, and an adjustment based on a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a decay factor that gradually decreases the score contribution of higher rest capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n indices = np.log(np.arange(1, len(bins) + 1))\\n cumulative_sum = np.cumsum(bins) \\n decay_factor = 0.8\\n penalty_factor = 0.6\\n bonus_score = 20\\n \\n scores = indices * bins / (item + epsilon)\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n \\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the inverse of the indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that promotes the usage of lower rest capacities, and a decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = bins / item\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n\\n scores = ratios - inverse_indices\\n scores -= 0.7 * (bins == bins.max())\\n scores += 20 * (bins == item)\\n scores += 0.3 * (1 - ratios)\\n scores *= 0.9 ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments considering the bin indices, penalties for bins with maximum capacity, bonus scores for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.arange(len(bins)) # Simplified component: Initialize indices as range from 0 to len(bins)-1\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n\\n scores = bins / (item + epsilon) + np.log(indices + 1)\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone Idea: The common backbone idea in all the provided algorithms is to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew Algorithm Description: The score function will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, and an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.7\\n bonus_score = 20\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will calculate the scores for each bin based on the ratio of each bin's remaining capacity to the item size, with additional penalties for bins with higher indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities divided by the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n bonus_score = 15\\n decay_factor = 0.85\\n cumulative_sum = np.cumsum(bins)\\n max_capacity = bins.max()\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == max_capacity)\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / max_capacity)\\n scores *= (cumulative_sum / max_capacity)\\n \\n return scores\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.9\\n bonus_score = 15\\n decay_factor = 0.85\\n cumulative_sum = np.cumsum(bins)\\n max_capacity = bins.max()\\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == max_capacity)\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / max_capacity)\\n scores *= (cumulative_sum / max_capacity)\\n \\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin based on a combination of the ratio of each bin's remaining capacity to the item size, a penalty factor for bins with lower indices, a bonus score for bins with rest capacity equal to the item size, an exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, and an adjustment based on the cumulative sum of the remaining capacities, with different parameter settings compared to the provided algorithm.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 0.5 # Changed penalty factor to 0.5\\n bonus_score = 10 # Changed bonus score to 10\\n decay_factor = 0.95 # Changed decay factor to 0.95\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin based on the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, the exponential decay factor raised to the power of the cumulative sum of the rest capacities, a bonus score for bins with rest capacities equal to the item size, and a penalty factor for bins with maximum capacity, while also applying additional adjustments based on the bin indices and the ratio of each bin's rest capacity to the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.log(np.arange(1, len(bins) + 1))\\n decay_factor = 0.9\\n bonus_score = 10\\n penalty_factor = 0.5\\n cumulative_sum = np.cumsum(bins)\\n \\n ratios = bins / (item + epsilon)\\n \\n scores = ratios + indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n scores += bonus_score * (bins == item)\\n scores -= penalty_factor * (bins == bins.max())\\n \\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm adjusts the score for each bin based on the ratio of each bin's remaining capacity to the item size, with an additional bonus score for bins with rest capacity equal to the item size, an inverse bonus score for bins with higher indices, and a decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n \\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n bonus_score = 20\\n inverse_bonus_score = -10\\n decay_factor = 0.9\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios\\n scores += bonus_score * (bins == item)\\n scores += inverse_bonus_score * inverse_indices\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the scores for each bin by taking into account the ratio between the item's size and each bin's rest capacity, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, and a modified cumulative sum of the rest capacities that accounts for the decay rate over time.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scaling_factor = 100 # Simplified scaling factor for ratios\\n\\n ratios = bins / (item * scaling_factor)\\n cumulative_sum = np.cumsum(bins)\\n decay_factor = np.exp(-0.05 * (cumulative_sum / bins.max())) # Simplified decay factor\\n\\n scores = ratios\\n scores += 10 * (bins == item)\\n scores *= decay_factor\\n\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to calculate scores for each bin based on the ratio of the bin's remaining capacity to the item size, with an increased penalty factor for bins with lower indices, a larger bonus score for bins with rest capacity equal to the item size, and a higher exponential decay factor raised to the power of the ratio of each bin's remaining capacity to the maximum capacity, while also adjusting the scores based on the cumulative sum of the remaining capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6 # Small value to avoid division by zero\\n\\n ratios = bins / (item + epsilon)\\n inverse_indices = 1 / (np.arange(len(bins)) + 1)\\n penalty_factor = 1.2 # Increased penalty factor\\n bonus_score = 30 # Increased bonus score\\n decay_factor = 0.95 # Higher decay factor\\n cumulative_sum = np.cumsum(bins) \\n \\n scores = ratios - inverse_indices\\n scores -= penalty_factor * (bins == bins.max())\\n scores += bonus_score * (bins == item)\\n scores *= decay_factor ** (cumulative_sum / bins.max())\\n\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the provided algorithms calculate scores for each bin based on the ratio of the bin's rest capacity to the item size, with additional adjustments or penalties based on bin indices, rest capacity utilization, or other factors.\\n\\nNew algorithm description: The score function will calculate the scores for each bin by considering the ratio of each bin's rest capacity to the item size, the logarithm of the bin indices, a penalty factor for bins with maximum capacity, a bonus score for bins with rest capacity equal to the item size, an additional factor that encourages the utilization of bins with lower rest capacities, and an exponential decay factor based on the cumulative sum of the rest capacities divided by the maximum capacity, with adjusted values for the penalty factor, bonus score, and additional factor.\\n\\nNew Algorithm Code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-6\\n indices = np.arange(len(bins)) # Simplified component: Initialize indices as range from 0 to len(bins)-1\\n bonus_score = 15\\n additional_factor = 0.4\\n decay_factor = 0.95\\n\\n scores = bins / (item + epsilon) + indices\\n scores += bonus_score * (bins == item)\\n scores += additional_factor * (1 - bins / (item + epsilon))\\n scores *= decay_factor ** (np.cumsum(bins) / bins.max())\\n\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where the scores are calculated by dividing the remaining capacity by the item size and subtracting a factor based on the ratio of the remaining capacity to the maximum capacity, weighted by the cube of the index in the bins array, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n ratio = remaining_capacity / max_capacity \\n score = int(bins[i] / item) - ratio**3 * i**2 \\n scores[i] = max(score, 0) \\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign scores to each bin based on its remaining capacity compared to the item size.\\n\\nMy new algorithm: Assign scores to each bin based on the bin capacity and the item size, using a square root function to amplify the difference between smaller and larger capacities, while considering the inverse of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.sqrt(max_capacity - bins[i] + 1) / (1/item)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n \\n max_capacity = np.max(bins) # Maximum capacity of the bins\\n \\n # Calculate the score for each bin based on their rest capacity\\n scores[bins != max_capacity] = item * (max_capacity - bins[bins != max_capacity]) / (max_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on its remaining capacity compared to the item size, with the goal of minimizing the number of used bins.\\n\\nNew algorithm: \\nAssign scores to each bin based on the bin capacity and the item size, using a logarithmic function to amplify the difference between smaller and larger capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.log(max_capacity - bins[i] + 1)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their remaining capacity, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a quadratic formula involving the ratio of the capacity to the maximum capacity and the square of the index in the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - ratio**2 * i # Calculate the score based on division, ratio, and the square of the index\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity still have a score of zero, but bins with smaller capacities have higher scores according to a different formula.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] >= max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = (max_capacity - bins[i]) / item\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic formula. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins < max_capacity] = np.log(max_capacity - bins[bins < max_capacity] - item + 1)\\n return scores\",\n \"objective\": 0.04387,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on their remaining capacity, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic formula involving the ratio of the capacity to the maximum capacity and the logarithm of the index in the bins array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - np.log(i+1) * ratio # Calculate the score based on division, ratio, and the logarithm of the index\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.04497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with smaller capacities have higher scores based on a certain formula, and bins with the maximum capacity have a score of zero. In each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] < max_capacity:\\n score = (1.0 / (max_capacity - bins[i])) * (bins[i] - item + 1) # Calculate the score based on a certain formula\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.04608,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n scores = np.nan_to_num(scores, posinf=0, neginf=0)\\n return scores\",\n \"objective\": 0.0488,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to bins based on the rest capacity of each bin and the size of the current item. It calculates the scores by multiplying the rest capacity of each bin by a coefficient derived from the ratio between the rest capacity and the item size, and assigns the calculated scores to the corresponding bins in the scores array. It also takes into account the maximum capacity of a bin to ensure it is not used if its rest capacity equals the maximum capacity.\\n\\nNew score function implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n item_size = item\\n max_capacity = np.max(bins)\\n \\n scores = (bins * (bins - item_size) / (max_capacity * item_size)).astype(int)\\n scores[bins == max_capacity] = 0\\n \\n return scores\",\n \"objective\": 0.05111,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms assign scores to each bin based on the remaining capacity of the bin, taking into account factors such as the ratio of the remaining capacity to the maximum capacity and the index of the bin in the bins array.\\n\\nNew algorithm description: My new algorithm assigns scores to each bin based on a complex formula involving the remaining capacity of the bin, the ratio of the remaining capacity to the maximum capacity, and a quadratic function of the index in the bins array, all combined using a trigonometric function.\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n ratio = remaining_capacity / max_capacity \\n index_factor = math.sin(math.radians(i)) # Apply a trigonometric function to the index\\n score = int(bins[i] / item) - ratio**2 * index_factor # Calculate the score based on division, ratio, and the index factor\\n scores[i] = max(score, 0) \\n\\n return scores\",\n \"objective\": 0.05353,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm iterates over the rest capacities of bins, and assigns a score based on the following criteria: if the capacity equals the maximum capacity, the score is set to 0; otherwise, the score is calculated by dividing the capacity by the item size and subtracting a factor based on the ratio of the capacity to the maximum capacity, weighted by the square of the index in the bins array. The function then returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - ratio**2 # Calculate the score based on division and ratio\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.05685,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the cosine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * cos(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm squared of the square root of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.9.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(np.sqrt(bins - item)))**2)) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.9)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.1, the square of the number of times the bin has been used, the sine of the item size, and cosine of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.1) + (np.arange(len(bins)) ** 2) + np.sin(item) + (np.cos(item) / 0.5)\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.3, the square of the number of times the bin has been used, the tangent of the item size, and the square root of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(bins - item)) * np.log(item) + (np.exp(item) * 0.3) + (np.arange(len(bins)) ** 2) + np.tan(item) + (np.sqrt(item) / 0.5)\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score of each bin is determined by taking the sum of the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item))) ** np.log(bins) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using various mathematical functions.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential of the item size raised to the power of the difference between the bin's capacity and the item size, plus the natural logarithm of the item size multiplied by a constant factor of 0.5, and divided by the sum of the cosine of the bin's current capacity and the tangent of the item size, all multiplied by the constant factor of 0.7, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins * (1/np.sqrt(bins - item))) * (np.exp(item) ** (bins - item)) + (np.log(item) * 0.5) / (np.cos(bins) + np.tan(item)) * 0.7 * (1/bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the cube of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 3) + (np.sqrt(item) / (bins - item)) + ((1 / item) * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(0.5 * np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** (0.5 * np.log(bins - item))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 2\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(max_capacity - item))) * (item * (max_capacity - item)) + (np.arange(len(bins)) ** 2) + (item / (np.sqrt(bins - item) + 1e-7)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.8.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.8)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the sum of the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins + item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the cubic root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the product between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins * item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using various mathematical functions.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential of the item size raised to the power of the difference between the bin's capacity and the item size, plus the natural logarithm of the item size multiplied by a constant factor of 0.5, and divided by the sum of the cosine of the bin's current capacity and the tangent of the item size, all multiplied by the constant factor of 0.7, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins * (1/np.sqrt(bins - item))) * (np.exp(item) ** (bins - item)) + (np.log(item) * 0.5) / (np.cos(bins) + np.tan(item)) * 0.7 * (1/bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the cube of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 3) + (np.sqrt(item) / (bins - item)) + ((1 / item) * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the exponential function raised to the power of the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the log of the bin's current capacity, plus the square root of the number of times the bin has been used, the log of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the exponential function raised to the power of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.exp(np.log(np.sqrt(bins - item))))) * (np.log(bins) ** np.arange(len(bins))) + (np.sqrt(np.arange(len(bins)))) + (np.log(item) / (bins - item)) + ((item / bins) ** np.exp(bins - item))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 2\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(max_capacity - item))) * (item * (max_capacity - item)) + (np.arange(len(bins)) ** 2) + (item / (np.sqrt(bins - item) + 1e-7)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square root of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the reciprocal of the current item size multiplied by the bin's current capacity raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item * (bins - item))) * np.exp(np.log(bins) * np.arange(len(bins))) + np.sqrt(np.arange(len(bins))) + (np.sqrt(item) / (bins - item)) + (1 / item * bins) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nCalculate the score for each bin as the product of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the product between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins * item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity divided by the item size, and raised to the power of the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nPython implementation of the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) * item)) ** (np.log(bins) / item) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the cube of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 3) + (np.sqrt(item) / (bins - item)) + ((1 / item) * (1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's current capacity, plus the exponential function raised to the power of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the square root of the product of the item size and the inverse of the bin's current capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (np.log(bins) ** np.arange(len(bins))) + (np.exp(np.arange(len(bins)))) + (np.log(item) / (bins - item)) + (np.sqrt(item * (1 / bins)))\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 0.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(max_capacity - item))) * (item * (max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / (np.sqrt(bins - item) + 1e-7)) + np.exp(item) * 0.5\\n return scores\",\n \"objective\": 0.01338,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square root of the number of times the bin has been used, the square root of the item size divided by the difference between the bin's capacity and the item size, and the reciprocal of the current item size multiplied by the bin's current capacity raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item * (bins - item))) * np.exp(np.log(bins) * np.arange(len(bins))) + np.sqrt(np.arange(len(bins))) + (np.sqrt(item) / (bins - item)) + (1 / item * bins) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions.\\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the sum of the square root of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3) * np.sqrt((bins - item) + (bins - item) ** 2))) ** (bins / np.log(item)) * np.exp(item * (bins - item)) / ((1 / bins) * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\nCalculate the score for each bin as the product of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm_description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, subtracted by the cube root of the number of times the bin has been used, the difference between the bin's capacity and the item size divided by the square root of the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) ** 0.5)) * np.exp(np.log(bins) * np.arange(len(bins))) - ((np.arange(len(bins))) ** (1/3)) + ((bins - item) / np.sqrt(item)) + ((1 / item) * (1 / bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins - item) / (np.sqrt(bins - item) * sin(item)) + (np.exp(item * (bins - item)) / (2 * np.abs(bins - item))) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm_description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, subtracted by the cube root of the number of times the bin has been used, the difference between the bin's capacity and the item size divided by the square root of the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) ** 0.5)) * np.exp(np.log(bins) * np.arange(len(bins))) - ((np.arange(len(bins))) ** (1/3)) + ((bins - item) / np.sqrt(item)) + ((1 / item) * (1 / bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / np.log(item)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the natural logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity and divided by the square root of the item size to prioritize bins with higher capacities.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / item) * np.exp(item * (bins - item))\\n scores *= (1 / bins) / np.sqrt(item)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm_description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, subtracted by the cube root of the number of times the bin has been used, the difference between the bin's capacity and the item size divided by the square root of the item size, and the inverse of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) ** 0.5)) * np.exp(np.log(bins) * np.arange(len(bins))) - ((np.arange(len(bins))) ** (1/3)) + ((bins - item) / np.sqrt(item)) + ((1 / item) * (1 / bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the square root of the inverse of the bin's current capacity, raised to the power of the natural logarithm of the difference between the bin's capacity and the item size.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(bins - item))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (item * np.sqrt(1/bins)) ** np.log(bins - item)\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(np.log(bins) * np.arange(len(bins)))) / (np.sqrt(bins - item) * np.log(item) * np.exp(item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the product between the item size and the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the absolute difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the square root of the item size divided by the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(np.sqrt(item * (bins - item)))) * (np.exp(np.log(bins) * np.arange(len(bins)))) + (np.abs(bins - item)) ** (np.log(np.sqrt(item)/bins))\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the logarithm of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\nPython implementation of the new algorithm: \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) / (np.log(bins) * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(np.log(bins) * np.arange(len(bins)))) / (np.sqrt(bins - item) * np.log(item) * np.exp(item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the logarithm of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.cbrt(bins - item)) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (np.log(bins) * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate the score for each bin based on the bin's current capacity and the difference between the bin's capacity and the item size, utilizing various mathematical operations and functions.\\n\\nNew algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product between the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item * (bins - item))) ** np.log(bins) * np.exp(item * (bins - item)) * np.log(item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\n\\nThe new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores = scores / (1 / bins * np.sqrt(item))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, and the difference between the bin's capacity and the item size raised to the power of 2, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) * np.sqrt(item)\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. Finally, the scores are scaled by a constant factor to maintain self-consistency.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item) ** (1/3)) ** (bins / np.log(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.exp(np.log(bins) * np.arange(len(bins)))) / (np.sqrt(bins - item) * np.log(item) * np.exp(item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities, and finally multiplied by the square root of the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate the score for each bin based on the bin's current capacity and the difference between the bin's capacity and the item size, utilizing various mathematical operations and functions.\\n\\nNew algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product between the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item * (bins - item))) ** np.log(bins) * np.exp(item * (bins - item)) * np.log(item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the rest capacity of the bin divided by the difference between the bin's capacity and the item size, plus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, (bins - item)) + (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the sum of the bin's remaining capacity and the item size divided by the bin's remaining capacity minus the item size, while also taking into account the logarithm of the item size and the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + math.log(item)\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = bins[i] / (bins[i] - item + 1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = (bins[i] / (bins[i] - item + 1)) + (1/item) * (i+1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where the scores are calculated by dividing the remaining capacity by the item size and subtracting a factor based on the ratio of the remaining capacity to the maximum capacity, weighted by the cube of the index in the bins array, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n ratio = remaining_capacity / max_capacity \\n score = int(bins[i] / item) - ratio**3 * i**2 \\n scores[i] = max(score, 0) \\n\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign scores to each bin based on its remaining capacity compared to the item size.\\n\\nMy new algorithm: Assign scores to each bin based on the bin capacity and the item size, using a square root function to amplify the difference between smaller and larger capacities, while considering the inverse of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.sqrt(max_capacity - bins[i] + 1) / (1/item)\\n \\n return scores\",\n \"objective\": 0.04004,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the bin capacity and the item size, using a logarithmic function to amplify the difference between smaller and larger capacities, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.log(max_capacity - bins[i] + 1) / (1/item)\\n \\n return scores\",\n \"objective\": 0.04025,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assign scores to each bin based on its remaining capacity compared to the item size.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's remaining capacity, the logarithm of the item size, and a factor that increases with the number of times the bin has been used, while incorporating a square root function to emphasize the impact of remaining capacity on the score.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n log_item = math.log(item)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n remaining_capacity = max_capacity - bins[i]\\n index_factor = math.sqrt(i + 1) # Apply square root to the index\\n score = remaining_capacity * log_item + index_factor * (bins[i] // item)\\n scores[i] = max(score, 0)\\n \\n return scores\",\n \"objective\": 0.04055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n \\n max_capacity = np.max(bins) # Maximum capacity of the bins\\n \\n # Calculate the score for each bin based on their rest capacity\\n scores[bins != max_capacity] = item * (max_capacity - bins[bins != max_capacity]) / (max_capacity + 1)\\n \\n return scores\",\n \"objective\": 0.04065,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a logarithmic formula. In each step, the item will be assigned to the bin with the maximum score, and if the remaining capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = bins.max()\\n scores = np.zeros_like(bins)\\n scores[bins < max_capacity] = max_capacity - bins[bins < max_capacity] - item\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, and the number of times the bin has been used. This algorithm aims to minimize the number of used bins by prioritizing bins with larger remaining capacities, smaller item sizes, and fewer previous uses.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * bins / (bins - item + np.arange(len(bins)))) / (np.arange(len(bins)) + 1)\\n return scores\",\n \"objective\": 0.04135,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on its remaining capacity compared to the item size, with the goal of minimizing the number of used bins.\\n\\nNew algorithm: \\nAssign scores to each bin based on the bin capacity and the item size, using a logarithmic function to amplify the difference between smaller and larger capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = np.log(max_capacity - bins[i] + 1)\\n \\n return scores\",\n \"objective\": 0.04216,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns scores to each bin based on their remaining capacity, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a quadratic formula involving the ratio of the capacity to the maximum capacity, the square of the index in the bins array, and a constant value k.\\n\\nNew code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = bins.max()\\n k = 2\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n ratio = bins[i] / max_capacity # Calculate the ratio of current capacity to maximum capacity\\n score = int(bins[i] / item) - ratio**2 * i - k # Calculate the score based on division, ratio, the square of the index, and the constant value k\\n scores[i] = max(score, 0) # Set score to 0 if negative\\n\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) * np.sqrt(item)\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00624,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the logarithm of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities. The scores are then scaled by a constant factor to maintain self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(np.log(bins - item))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item))\\n scores /= (1 / bins) * np.sqrt(item)\\n scores *= 100 # scaler constant factor\\n return scores\",\n \"objective\": 0.00634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The proposed algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the sum of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities, and multiply the score by the summation of the exponential function raised to the power of the item size multiplied by the square root of the bin's capacity raised to the power of 2. \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item) + (bins - item) ** 2)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins * (np.exp(item) * np.sqrt(bins) ** 2)\\n return scores\",\n \"objective\": 0.00644,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the natural logarithm of the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity squared to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.sqrt(item)) ** (bins / (bins - item)) * np.log(np.exp(item * (bins - item)))) / (bins ** 2)\\n return scores\",\n \"objective\": 0.00654,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm: Calculate the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, divide the score by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00664,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** (1/3))) ** (bins / np.sqrt(item)) * np.exp(item * (bins - item)) / (1 / (bins * np.sqrt(item)))\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the item size, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and multiplied by the square root of the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** (bins / item) * np.exp(item * (bins - item)) * np.sqrt(item) / bins\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity of the bin and the difference between the bin's capacity and the item size, using mathematical functions such as square root, logarithm, exponential, and trigonometric functions. \\n\\nNew algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm calculates the score for each bin as the product of the current capacity of the bin, the logarithm of the difference between the bin's capacity and the item size, the square root of the difference between the bin's capacity and the item size, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * np.log(bins - item) * np.sqrt(bins - item) * np.exp(item * (bins - item))) / (1/bins)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, and multiplied by the exponential function raised to the power of the item size.\\n\\nPython implementation of the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.exp(np.log(bins) * np.arange(len(bins))) / (np.sqrt(bins - item))\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, and divided by the reciprocal of the bin's current capacity to prioritize bins with lower capacities, and finally multiplied by the square root of the item size.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins) * np.sqrt(item)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate the score for each bin based on the bin's current capacity and the difference between the bin's capacity and the item size, utilizing various mathematical operations and functions.\\n\\nNew algorithm description: The proposed algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product between the item size and the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(item * (bins - item))) ** np.log(bins) * np.exp(item * (bins - item)) * np.log(item)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity to prioritize bins with higher capacities.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) / (1/bins)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the item size, raised to the power of the bin's current capacity divided by the difference between the bin's capacity and the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((bins / np.log(item)) ** (bins / (bins - item)) * np.exp(item * (bins - item))) / bins\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the square root of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the item size multiplied by the reciprocal of the bin's current capacity, raised to the power of the square root of the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.sqrt(bins) * np.exp(item * (bins - item)) / ((1 / item) * (1 / bins)) ** np.sqrt(bins - item)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1 / (1 - item/bins)) ** np.log(bins) * np.exp(item * (bins - item)) / bins\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm: The algorithm calculates the score for each bin as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size, and finally multiplied by the reciprocal of the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / (bins - item)) ** bins * np.exp(item * (bins - item)) / ((1 / bins) * np.sqrt(item)) * (1 / item)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item) ** bins)) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the product of the bin's current capacity divided by the cube root of the difference between the bin's capacity and the item size, raised to the power of the bin's current capacity divided by the square root of the item size, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is divided by the reciprocal of the bin's current capacity multiplied by the square root of the item size to prioritize bins with higher capacities.\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) * np.exp(item * (bins - item))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common Backbone Idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the difference between the bin's capacity and the item size, plus the number of times the bin has been used squared, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a factor that takes into account the square of the difference between the bin's capacity and the item size, while also applying a logarithmic function to promote performance.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (np.sqrt(bins - item) ** 2) + np.log10(np.exp(item))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log((bins - item) * (bins - item))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: Assign scores to each bin based on the bin's current capacity multiplied by the item size divided by the log value of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.log(bins - item) ** 2) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, item size, the number of times the bin has been used, and a certain function that incorporates the item size and promotes performance.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / (bins - item + 1)) + np.exp(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) // (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, which is calculated as the rest capacity of the bin divided by the difference between the bin's capacity and the item size, plus twice the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, (bins - item)) + (2 * np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-10 # Small value to avoid division by zero\\n \\n scores = bins / (bins - item) + np.sqrt(bins) / np.sqrt(bins - item) + np.arange(len(bins))\\n \\n # Set scores of bins with rest capacity equals maximum capacity to negative infinity\\n scores[bins == np.max(bins)] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on its remaining capacity, item size, and the number of times it has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a logarithmically decreasing function.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n \\n max_capacity = np.max(bins) # Maximum capacity of the bins\\n \\n # Calculate the score for each bin based on remaining capacity, item size, number of uses, and logarithmic function\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = item / (bins[i] - item + 1) + np.log(item) / (np.log(bins[i] + 1) * (i + 1))\\n \\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus a constant factor multiplied by the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + 0.5 * np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, the sum of the logarithm of the bin's current capacity and the item size divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.log(bins + item) / np.sqrt(bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, and the number of times the bin has been used, and returns the scores for the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = bins[i] / (bins[i] - item + 1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\nThe new algorithm assigns scores to each bin based on the bin's current capacity, the difference between the bin's capacity and the item size, and a factor that increases with the number of times the bin has been used, while considering the reciprocal of the item size to promote performance and compatibility with the existing algorithms.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n score = (bins[i] / (bins[i] - item + 1)) + (1/item) * (i+1)\\n scores[i] = score\\n \\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) + np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on a combination of the bin's capacity, the item size, and the number of times the bin has been used. It also incorporates a logarithmic function to further promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) ** 2)) * np.log(1 + np.arange(len(bins))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's capacity, the item size, and the average of the rest capacities of the feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_rest_capacity = np.mean(bins)\\n scores = bins / ((bins - item) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) * avg_rest_capacity\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a factor that takes into account the square of the difference between the bin's capacity and the item size, while also applying a logarithmic function to promote performance.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (np.sqrt(bins - item) ** 2) + np.log10(np.exp(item))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the combination of the bin's current capacity divided by the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the item size, the logarithm of the bin's capacity divided by the logarithm of the item size, and the exponential of the number of times the bin has been used, while also applying a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / np.sqrt(item)) + (np.log(bins) / np.log(item)) + np.exp(item) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size plus the number of times the bin has been used, and also multiplies it by the logarithm of the item size to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins)) * np.log(item)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.log((bins - item) * (bins - item))) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02183,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity, the item size, the logarithm of the difference between the bin's capacity and the item size, and the square of the number of times the bin has been used. It then applies a power function to promote performance and returns the scores for the bins.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / ((np.log(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Backbone idea: The provided algorithms assign scores to the bins based on a combination of the bin's current capacity, the item size, the difference between the bin's capacity and the item size, the logarithm and square root of this difference, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size, an additional term incorporating the reciprocal of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log((bins - item) * np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item) + (1 / item) + (0.5 * (bins / item))\\n return scores\",\n \"objective\": 0.02324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm and main steps: \\nThe new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the logarithm of the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance. \\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log((bins - item) * np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.02405,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Assigning scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: Assign scores to each bin based on the bin's current capacity multiplied by the item size divided by the log value of the difference between the bin's capacity and the item size, plus the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.log(bins - item) ** 2) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02606,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Assign scores to each bin based on the bin's current capacity multiplied by the item size divided by the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and take the exponential of the result.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2)\\n scores = np.exp(scores) \\n return scores\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the difference between the bin's capacity and the item size, and the cube of the number of times the bin has been used, while also applying a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (bins / (bins - item)) + (np.arange(len(bins)) ** 3)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, item size, the number of times the bin has been used, and a certain function that incorporates the item size and promotes performance.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) + (np.sqrt(bins) / (bins - item + 1)) + np.exp(item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.0324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the bin's current capacity divided by the difference between the bin's capacity and the item size, and the cube of the number of times the bin has been used, while also applying a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(np.sqrt(bins - item)))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (bins / (bins - item)) + (np.ones(len(bins)) * 100)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.03521,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the bin's current capacity, the item size, and the number of times the bin has been used. Additionally, various mathematical operations such as square root, logarithm, and exponential functions are applied to these values to promote performance.\\n\\nBased on this backbone idea, the new algorithm assigns scores to each bin by taking the square root of the bin's current capacity multiplied by the item size, and then dividing it by the logarithm of the square of the difference between the bin's capacity and the item size, all while considering the number of times the bin has been used and applying an exponential function for performance promotion.\\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins * item) / (np.log((bins - item) ** 2))\\n scores += np.arange(len(bins)) + np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.03542,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt((bins - item) * np.log(np.sqrt(bins - item))))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and apply a power function to promote performance.\\n\\nPython code for the new algorithm:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((np.log(bins - item) * np.sqrt(bins - item)) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt((bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used, multiplied by a constant factor of 2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + 2 * np.sqrt(np.arange(len(bins)))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the reciprocal of the item size times the logarithm of the bin's capacity, and the cube of the item size divided by the difference between the bin's capacity and the item size, while also applying a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((1 / item) * np.log(bins)) + ((item ** 3) / (bins - item))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a larger remaining capacity ratio. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size minus the sum of the first and last digits of the item size, the reciprocal of the item size, an additional term incorporating the reciprocal of the square root of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size plus the square root of the item size.\\n\\nPython code for the new algorithm:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) * np.sqrt(bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item - int(str(item)[0]) - int(str(item)[-1])) + (1 / item) + ((1 / np.sqrt(item)) / item) + (0.5 * (bins / item + np.sqrt(item)))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size, multiplied by the number of times the bin has been used squared divided by the item size, added to a constant factor multiplied by the item size divided by the bin's current capacity, and finally applying a power function to promote performance by adding the exponential of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) * ((np.arange(len(bins)) ** 2) / item) + (0.3 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's capacity, the item size, and the average of the rest capacities of the feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_rest_capacity = np.mean(bins)\\n scores = bins / ((bins - item) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) * avg_rest_capacity\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity, the item size, the number of times the bin has been used, and a factor that takes into account the square of the difference between the bin's capacity and the item size, while also applying a logarithmic function to promote performance.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (np.sqrt(bins - item) ** 2) + np.log10(np.exp(item))\\n return scores\",\n \"objective\": 0.01881,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity divided by the logarithm of the item size, plus the exponential of the number of times the bin has been used and a power function to promote performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (np.log(bins) / np.log(item)) + np.exp(item) ** np.arange(len(bins))\\n return scores\",\n \"objective\": 0.01902,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / np.sqrt(bins - item) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01912,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02103,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the square root of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size plus the number of times the bin has been used, and also multiplies it by the logarithm of the item size to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (np.sqrt((bins - item) * (bins - item)) + np.sqrt((bins - item) * (bins - item))) + np.arange(len(bins)) * np.log(item)\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.02123,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.square(bins) * np.log(bins)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the product of the difference between the bin's capacity and the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt((bins - item) * np.log(np.sqrt(bins - item))))) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the provided algorithms, the common backbone idea is to calculate scores based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.5.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.sqrt(bins) / (bins - item)) * np.log(bins)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item)) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / ((bins - item) * np.log(bins / np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on a combination of the bin's current capacity squared divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used divided by the item size, and the square root of the item size multiplied by the logarithm of the bin's capacity, and apply a power function to promote performance.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins ** 2) / ((np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (np.sqrt(item) * np.log(bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the product of the bins and the item.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the reciprocal of the item size times the logarithm of the bin's capacity, and the cube of the item size divided by the difference between the bin's capacity and the item size, while also applying a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((1 / item) * np.log(bins)) + ((item ** 3) / (bins - item))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a larger remaining capacity ratio. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size minus the sum of the first and last digits of the item size, the reciprocal of the item size, an additional term incorporating the reciprocal of the square root of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size plus the square root of the item size.\\n\\nPython code for the new algorithm:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) * np.sqrt(bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item - int(str(item)[0]) - int(str(item)[-1])) + (1 / item) + ((1 / np.sqrt(item)) / item) + (0.5 * (bins / item + np.sqrt(item)))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a smaller remaining capacity ratio.\\n\\nNew code implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = 1 - bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it introduces a term incorporating the reciprocal of the item size, the product of the bin's remaining capacity ratio and the square root of the difference between the bin's capacity and the item size, and the exponential of the item size. \\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity_ratio = bins / np.max(bins)\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (1 / item) * (remaining_capacity_ratio * np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and the logarithm of the product of the bin's capacity and the item size, divided by the square root of the sum of the squares of the bin sizes, multiplied by a constant factor and added to a power function that incorporates the size of the current item and promotes performance.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.log(bins * item) / np.sqrt(np.sum(bins ** 2)) + (0.5 * (item / bins)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0165,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size, and the square root of the difference between the bin's capacity and the item size, multiplied by the number of times the bin has been used squared divided by the item size, added to a constant factor multiplied by the item size divided by the bin's current capacity, and finally applying a power function to promote performance by adding the exponential of the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) * ((np.arange(len(bins)) ** 2) / item) + (0.3 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's capacity, the item size, and the average of the rest capacities of the feasible bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_rest_capacity = np.mean(bins)\\n scores = bins / ((bins - item) ** 2) + (np.arange(len(bins)) ** 2)\\n scores += np.exp(item) * avg_rest_capacity\\n return scores\",\n \"objective\": 0.01731,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.square(bins) * np.log(bins)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm:\\nThe new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the square root of the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the square root of the item size divided by the bin's current capacity, and applies a power function to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(np.log(bins - item) * np.sqrt(bins - item)))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (np.sqrt(item) / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the logarithm of the number of times the bin has been used, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size divided by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (item * np.log(np.arange(len(bins)) + 1)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) / 2\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the product of the bins and the item.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the reciprocal of the item size times the logarithm of the bin's capacity, and the cube of the item size divided by the difference between the bin's capacity and the item size, while also applying a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((1 / item) * np.log(bins)) + ((item ** 3) / (bins - item))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and the ratio of the remaining capacity to the item size, while also considering a certain function that incorporates the size of the current item and promotes performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + bins / item\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used, the exponential of the item size minus the sum of the first and last digits of the item size, the reciprocal of the item size, an additional term incorporating the reciprocal of the square root of the item size, and a constant factor multiplied by the bin's current capacity divided by the item size plus the square root of the item size.\\n\\nPython code for the new algorithm:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / ((bins - item) * np.sqrt(bins - item))) + (np.sqrt(bins) / np.sqrt(bins - item)) + np.arange(len(bins)) + np.exp(item - int(str(item)[0]) - int(str(item)[-1])) + (1 / item) + ((1 / np.sqrt(item)) / item) + (0.5 * (bins / item + np.sqrt(item)))\\n return scores\",\n \"objective\": 0.016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the ratio of the remaining capacity of a bin to the maximum capacity, assigning higher scores to bins with a smaller remaining capacity ratio.\\n\\nNew code implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity_ratio = 1 - bins / max_capacity\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.0162,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it introduces a term incorporating the reciprocal of the item size, the product of the bin's remaining capacity ratio and the square root of the difference between the bin's capacity and the item size, and the exponential of the item size. \\n\\nPython code for the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity_ratio = bins / np.max(bins)\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + (1 / item) * (remaining_capacity_ratio * np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0163,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the cosine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * cos(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.square(bins) * np.log(bins)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.1, the square of the number of times the bin has been used, the sine of the item size, and cosine of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.1) + (np.arange(len(bins)) ** 2) + np.sin(item) + (np.cos(item) / 0.5)\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"new_algorithm:\\nThe new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the square root of the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the square root of the item size divided by the bin's current capacity, and applies a power function to promote performance.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(np.log(bins - item) * np.sqrt(bins - item)))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (np.sqrt(item) / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the logarithm of the number of times the bin has been used, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size divided by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (item * np.log(np.arange(len(bins)) + 1)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) / 2\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, and the number of times the bin has been used, while also considering a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the product of the bins and the item.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on a combination of the bin's remaining capacity divided by the logarithm of the difference between the bin's capacity and the item size, the square root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) + (np.sqrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.log(bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.0156,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the cosine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n```\",\n \"code\": \"import numpy as np\\nfrom math import cos\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * cos(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the exponential function raised to the power of the natural logarithm of the bin's current capacity, plus the square of the number of times the bin has been used, the logarithm of the item size divided by the difference between the bin's capacity and the item size, and the product of the item size and the reciprocal of the bin's current capacity.\\n\\nPython implementation of the new algorithm:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.exp(np.log(bins) * np.arange(len(bins))) + (np.arange(len(bins)) ** 2) + (np.log(item) / (bins - item)) + (1 / bins)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the sine of the natural logarithm of the item size, plus the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size, divided by the sum of the absolute differences between the bin's capacity and the item size and the current item size, and finally, multiplied by the reciprocal of the bin's current capacity.\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sin\\n\\ndef score(item, bins):\\n scores = (bins / ((np.log(bins - item) * np.sqrt(bins - item)) * sin(np.log(item)))) + (np.exp(item * (bins - item)) / (np.abs(bins - item) + np.abs(bins - item).sum())) * (1 / bins)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of the natural logarithm of the bin's current capacity, and multiplied by the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size. Additionally, the score is multiplied by the reciprocal of the bin's current capacity to prioritize bins with lower capacities.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) ** np.log(bins) * np.exp(item * (bins - item)) * (1/bins)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the product of the square of the bin's capacity and the logarithm of the bin's current capacity, and the exponential function raised to the power of the item size multiplied by the difference between the bin's capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) + (np.exp(item * (bins - item)))\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assign scores to each bin based on the bin's capacity, the item size, the number of times the bin has been used, and a function that incorporates the size of the current item.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 1.5.\\n\\nPython implementation of the new algorithm:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(np.sqrt(max_capacity - item)))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 1.5\\n return scores\",\n \"objective\": 0.01358,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of their remaining capacity, the item size, the number of times the bin has been used, and a certain function that incorporates the size of the current item and promotes performance. Additionally, it takes into account the square root of the difference between the bins and the item, multiplied by a scaling factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins + item) / (bins - item) + np.arange(len(bins)) + np.exp(item) + np.sqrt(0.1 * (bins - item)) + np.sqrt(bins * item)\\n return scores\",\n \"objective\": 0.01368,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the product of the item size and the difference between the bin's capacity and the item size, multiplied by the logarithm of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * (bins - item) * np.log(bins - item))) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.5)\\n return scores\",\n \"objective\": 0.01378,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the bin's current capacity divided by the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the square root of the difference between the bin's capacity and the item size, plus the square root of the item size, the square of the number of times the bin has been used, and the exponential of the item size multiplied by a constant factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (item * np.sqrt(bins - item) * np.log(np.sqrt(bins - item)))) + np.sqrt(item) + (np.arange(len(bins)) ** 2) + (np.exp(item) * 0.7)\\n return scores\",\n \"objective\": 0.01388,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates the score for each bin as the sum of the bin's current capacity divided by the cube root of the product of the difference between the bin's capacity and the item size and the natural logarithm of the difference between the bin's capacity and the item size, the cube root of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.cbrt((bins - item) * np.log(bins - item)))) + (np.cbrt(bins) / np.sqrt(bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01409,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.round((bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25), 2)\\n return scores\",\n \"objective\": 0.01419,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.1, the square of the number of times the bin has been used, the sine of the item size, and cosine of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.1) + (np.arange(len(bins)) ** 2) + np.sin(item) + (np.cos(item) / 0.5)\\n return scores\",\n \"objective\": 0.01439,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the bin's current capacity divided by the product of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, the number of times the bin has been used squared divided by the item size, and a constant factor multiplied by the item size divided by the bin's current capacity, and applies a power function to promote performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.log(bins - item) * np.sqrt(bins - item))) + ((np.arange(len(bins)) ** 2) / item) + (0.1 * (item / bins))\\n scores += np.exp(item) # Apply a power function to promote performance\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.2, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * np.log(item) + (np.exp(item) * 0.2) + (np.arange(len(bins)) ** 2) + np.sin(item)\\n return scores\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on the bin's current capacity divided by the sine of the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size, plus the exponential of the item size multiplied by a constant factor of 0.3, the square of the number of times the bin has been used, the tangent of the item size, and the square root of the item size divided by a factor of 0.5, all multiplied by the constant factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sin(bins - item)) * np.log(item) + (np.exp(item) * 0.3) + (np.arange(len(bins)) ** 2) + np.tan(item) + (np.sqrt(item) / 0.5)\\n return scores\",\n \"objective\": 0.01469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Assign scores to each bin based on the product of the bin's current capacity and the reciprocal of the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the square of the number of times the bin has been used, the square root of the item size, and the exponential of the item size multiplied by a constant factor of 0.25. Each element in the scores array is rounded to 2 decimal places.\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) * np.log(bins) + (np.arange(len(bins)) ** 2) + np.sqrt(item) + (np.exp(item) * 0.25)\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning scores to each bin based on a combination of the bin's capacity, the item size, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: Assign scores to each bin based on the bin's current capacity divided by the sum of the logarithm of the difference between the bin's capacity and the item size and the square root of the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used, the square of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size.\\n\\nPython code for the new algorithm:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (np.sqrt(bins - item))) + (np.arange(len(bins)) ** 2) + ((item ** 2) / np.sqrt(bins - item)) + np.exp(item)\\n return scores\",\n \"objective\": 0.01489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the new algorithm, the scores for each bin will be calculated based on the bin's current capacity divided by the logarithm of the difference between the bin's capacity and the item size, then multiplied by the product of the item size and the square root of the difference between the maximum capacity and the item size, along with the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size multiplied by a constant factor of 2.0.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / (np.log(bins - item))) * (item * np.sqrt(max_capacity - item)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) * 2.0\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm calculates the score for each bin as the sum of the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size and the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, the square of the number of times the bin has been used, and a function that incorporates the size of the current item and promotes performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)) + (np.arange(len(bins)) ** 2) + np.exp(item)\\n return scores\",\n \"objective\": 0.01519,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The previous algorithms assign scores to each bin based on a combination of the bin's capacity, the item size, the number of times the bin has been used, and certain functions that incorporate the size of the current item.\\n\\nNew algorithm description: The new algorithm assigns scores to each bin based on the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the product of the item size and the logarithm of the number of times the bin has been used, plus the square of the number of times the bin has been used, the square root of the item size divided by the square root of the difference between the bin's capacity and the item size, and the exponential of the item size divided by a constant factor of 2.\\n\\nPython implementation of the new algorithm:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / np.sqrt(bins - item)) * (item * np.log(np.arange(len(bins)) + 1)) + (np.arange(len(bins)) ** 2) + (np.sqrt(item) / np.sqrt(bins - item)) + np.exp(item) / 2\\n return scores\",\n \"objective\": 0.01529,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm assigns scores to each bin based on the remaining capacity of the bin, where bins with the maximum capacity have a score of zero, and bins with smaller capacities have higher scores based on a certain formula.\\nIn each step, the item will be assigned to the bin with the maximum score, and if the rest capacity of a bin equals the maximum capacity, it will not be used.\\nThe final goal is to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(0, (bins.max() - bins) - item)\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a novel scoring function that maximizes the score of each bin, while avoiding using bins with the maximum rest capacity. The goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n\\n scores[bins != max_capacity] = (bins[bins != max_capacity] - item) / (max_capacity - item)\\n\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"One way to design the novel score function is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize scores array with zeros\\n bin_capacities = np.where(bins != item, bins, 0) # Exclude bins with exact capacity\\n\\n # Calculate the scores for each bin based on the remaining capacity\\n scores = np.where(bin_capacities > 0, 1/bin_capacities, 0)\\n\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratio of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by multiplying the ratios with an increasing factor\\n scores = ratios * np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.12184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, calculated by subtracting the item size from the bin capacity, and avoids using bins with the maximum capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins - item\\n scores[bins == np.max(bins)] = np.min(scores) - 1\\n return scores\",\n \"objective\": 0.13211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy algorithm calculates the score for each bin based on its current rest capacity and the size of the item, where the score is equal to the absolute value of the difference between the rest capacity and the item size, multiplied by -1 if the bin is empty, to prioritize filling the empty bins first, or multiplied by 1 if the bin is not empty.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.abs(bins - item) * np.where(bins == np.max(bins), 0, np.where(bins == np.max(bins) - item, -1, 1))\\n return scores\",\n \"objective\": 0.13281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\n1. Initialize an empty Numpy array called 'scores'.\\n2. Iterate through each bin capacity in 'bins'.\\n3. If the bin capacity is equal to the maximum capacity (i.e. not used), assign a score of 0.\\n4. If the bin capacity is greater than the item size, assign a score of the bin capacity minus the item size.\\n5. If the bin capacity is less than or equal to the item size, assign a negative score of 1000.\\n6. Append the score to the 'scores' array.\\n7. Return the 'scores' array as the output of the function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.empty_like(bins)\\n max_capacity = np.max(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1000\\n \\n return scores\",\n \"objective\": 0.14418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the score for each bin by dividing the rest capacity of the bin by the item size, then subtracting 1 if the rest capacity equals the maximum capacity. Next, it sets the score to 0 if the rest capacity is less than the item size. Finally, it returns the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.divide(bins, item)\\n scores[bins == np.max(bins)] -= 1\\n scores[bins < item] = 0\\n return scores\",\n \"objective\": 0.32428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns the item to the bin with the maximum score, considering the rest capacity of the bin, and returns the scores for all bins after the assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins) # Initialize an array of scores with zeros\\n\\n # Calculate the score for each bin based on their rest capacity\\n scores = np.where(bins == np.max(bins), 0, bins - np.max(bins) + item + 1)\\n \\n return scores\",\n \"objective\": 0.32971,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the ratio of the capacity remaining in each bin to the size of the current item.\\n2. Assign a score of 0 to bins that have the same capacity as their maximum capacity.\\n3. Assign a score of 1 to bins whose remaining capacity is 1 larger than the size of the current item.\\n4. Assign a score of 2 to bins whose remaining capacity is 2 larger than the size of the current item.\\n5. Assign a score of 3 to bins whose remaining capacity is 3 larger than the size of the current item.\\n6. Continue this pattern and assign scores in increasing order to bins with increasing available capacity.\\n7. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n scores[remaining_capacity < 0] = -1 # Mark bins with not enough capacity as -1\\n scores[remaining_capacity > 0] = np.floor(remaining_capacity[remaining_capacity > 0] / item) # Assign scores based on ratio\\n return scores\",\n \"objective\": 0.36543,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm scores each bin based on a score function that takes into account both the remaining capacity of the bin and the size of the item being assigned. The main steps of the algorithm are: \\n1. Initialize an empty Numpy array 'scores' with the same size as 'bins' to store the scores for each bin.\\n2. Calculate the score for each bin by dividing the remaining capacity of the bin by the size of the item, and store the result in the corresponding index of 'scores'.\\n3. Return the 'scores' array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins > item] = bins[bins > item] / item\\n return scores\",\n \"objective\": 0.3763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm takes the input of the size 'item' and the rest capacities of feasible bins 'bins' and outputs the scores for the bins for assignment.\\nThe main steps of the algorithm are as follows:\\n1. Calculate the available capacities of all bins by subtracting 'item' from 'bins'.\\n2. Filter out the bins with available capacity equal to the maximum capacity ('bins_max') using a mask.\\n3. Assign a score of 0 to all bins that have 'bins_max' capacity.\\n4. For the remaining bins, calculate the score by dividing the available capacity by the difference between 'bins_max' and the available capacity.\\n5. Return the 'scores' array as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n bins_max = np.max(bins)\\n capacities = bins - item\\n mask = capacities != bins_max\\n scores = np.zeros_like(bins)\\n scores[mask] = capacities[mask] / (bins_max - capacities[mask])\\n return scores\",\n \"objective\": 0.79445,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm assigns the item to the bin with the maximum score, where the score for each bin is calculated as the difference between the rest capacity and twice the size of the item, with a lower bound of zero, and the final scores are stored in a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - 2 * item, 0)\\n return scores\",\n \"objective\": 0.86699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The novel score function assigns an item to the bin with the maximum score, taking into account the rest capacity of each bin, and aims to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n mask = bins != np.max(bins)\\n scores[mask] = item - bins[mask]\\n return scores\",\n \"objective\": 0.89597,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"We first calculate the scores for each bin by dividing the rest capacity of each bin by the size of the current item, and then subtract 1 from the score of the bin with the maximum capacity. Finally, we return the scores as a Numpy array.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / item\\n max_index = np.argmax(bins)\\n scores[max_index] -= 1\\n return scores\",\n \"objective\": 1.51484,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm calculates the score for each bin by dividing the rest capacity of the bin by the size of the item and subtracting it from the maximum score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_score = np.max(bins) / item\\n scores = (bins / item) - max_score\\n return scores\",\n \"objective\": 1.51534,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm calculates the scores for the bins based on the ratio of their remaining capacity to the size of the current item, their relative positions, and a penalty factor for larger bins, with higher scores given to bins with smaller ratios, higher positions, and smaller penalty factors.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n # Calculate ratio of remaining capacity to item size\\n ratio = remaining_capacity / item\\n\\n # Calculate penalty factors for larger bins\\n penalty_factor = np.exp(-bins)\\n\\n # Assign scores based on ratio, bin position, and penalty factor\\n scores = ratio + np.arange(len(bins)) + penalty_factor\\n\\n return scores\",\n \"objective\": 0.04145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used, squared.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))**2\\n return scores\",\n \"objective\": 0.04226,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin. The scores are calculated by dividing the rest capacity of each bin by the item size, and then multiplying it with a decreasing factor.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity of each bin to the item size\\n ratios = bins.astype(float) / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios by an increasing factor\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n return scores\",\n \"objective\": 0.04246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to a bin with the maximum score, taking into account the rest capacity of the bins, and returns the scores for each bin. The scores are calculated by dividing the rest capacity of each bin by the item size, and then multiplying it with a decreasing factor. In addition, the algorithm considers the number of already used bins in the score calculation to promote minimizing the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate the ratios of rest capacity of each bin to the item size\\n ratios = bins / item\\n \\n # Set the score for bins with equal rest capacity to the maximum capacity as 0\\n ratios[bins == max(bins)] = 0\\n \\n # Calculate the scores for each bin by dividing the ratios by an increasing factor\\n scores = ratios / np.arange(1, len(bins)+1)\\n \\n # Adjust scores by considering the number of already used bins\\n scores *= np.exp(-0.1 * np.arange(0, len(bins)))\\n \\n return scores\",\n \"objective\": 0.04286,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"First, we calculate the remaining capacities of each bin after assigning the current item by subtracting the item size from the bin capacities. Then, we create a mask to identify the bins that still have remaining capacity and set their scores to an initial value of 1. Next, we divide the scores by the remaining capacities of the respective bins to adjust the scores based on the amount of remaining capacity. Finally, we return the scores as a numpy array.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins\\n mask = remaining_capacities > item\\n scores = np.zeros_like(bins, dtype=np.float64)\\n scores[mask] = 1 / remaining_capacities[mask]\\n return scores\",\n \"objective\": 0.05071,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\nThe new algorithm assigns items to bins based on a score function that takes into account both the difference between the current item and the rest capacities of bins and the number of times each bin has been used. The score for each bin is calculated by multiplying the square root of the absolute difference between the current item and the rest capacity of the bin by a factor of 0.5 and then adding the number of times the bin has been used.\\n\\nPython implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = np.sqrt(np.abs(remaining_capacities)) * 0.5 + used_counts\\n return scores\",\n \"objective\": 0.05473,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: \\n1. Initialize an empty array named scores with the same size as bins.\\n2. For each bin capacity in bins:\\n a. If the bin capacity equals the maximum capacity, set its score to 0.\\n b. Otherwise, calculate the score of the bin by dividing the bin capacity by the item size.\\n Note: If the division results in a floating-point value, round it down to the nearest integer.\\n c. Assign the calculated score to the corresponding index in scores array.\\n3. Return the scores array.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = int(bins[i] / item)\\n\\n return scores\",\n \"objective\": 0.05987,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that takes into account the ratio between the remaining capacity of each bin and the item size, the logarithm base 2 of the bin capacity, and the number of times each bin has been used, with higher scores given to bins with smaller ratios, larger logarithmic capacity, and smaller usage count.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = remaining_capacities / item + np.log2(bins * 2) + used_counts * (-0.2)\\n return scores\",\n \"objective\": 0.06359,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that takes into account the difference between the current item and the rest capacities of bins and the number of times each bin has been used. The score for each bin is calculated by raising the difference between the current item and the rest capacity of the bin to the power of 2.5, multiplying it by a factor of 0.3, and then adding the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (remaining_capacities - item) ** 2.5 * 0.3 + used_counts\\n return scores\",\n \"objective\": 0.0651,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the score function, where the score for each bin is calculated by taking the logarithm base 2 of the sum of the square root of the difference between the rest capacity of the bin and the item size and the product of the bin capacity and a factor of 0.5, then subtracting the number of times the bin has been used multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = np.log2(np.sqrt(bins - item) + (bins * 0.5)) - used_counts * 0.1\\n return scores\",\n \"objective\": 0.08019,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the algorithms calculate scores for each bin based on some criteria such as remaining capacity, difference in capacity, or number of times the bin has been used.\\n\\nNew algorithm description: \\n\\nThe new algorithm assigns items to bins based on a score function that takes into account the difference between the current item and the rest capacities of bins, the number of times each bin has been used, and the inverse of the bin capacity.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n inverse_capacities = 1 / bins\\n scores = np.sqrt(np.abs(remaining_capacities)) + used_counts * 0.5 + inverse_capacities\\n return scores\",\n \"objective\": 0.08049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: All the algorithms calculate scores for each bin based on some criteria such as remaining capacity, difference in capacity, or number of times the bin has been used.\\n\\nNew algorithm description: \\n\\nThe new algorithm assigns items to bins based on a score function that takes into account the difference between the current item and the rest capacities of bins, and the number of times each bin has been used. The score for each bin is calculated by adding the square root of the difference between the current item and the rest capacity of the bin, and the number of times the bin has been used, multiplied by a factor of 0.5.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = np.sqrt(np.abs(remaining_capacities)) + used_counts * 0.5\\n return scores\",\n \"objective\": 0.0822,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm scores the bins based on a combination of their remaining capacity and their positions in the list, with higher scores given to bins with larger capacities and lower positions in the list.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n remaining_capacity = bins - item\\n\\n # Assign scores based on remaining capacity and bin position\\n scores = remaining_capacity + (len(bins)-1) - np.arange(len(bins))\\n\\n return scores\",\n \"objective\": 0.10102,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on the score function, where the score for each bin is calculated by multiplying the square root of the difference between the rest capacity of the bin and the item size by a factor of 0.5, and then subtracting the number of times the bin has been used multiplied by 0.1, and finally multiplying it with the item size divided by the maximum capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = np.sqrt(bins - item) * 0.5 - used_counts * 0.1\\n scores *= item / np.max(bins)\\n return scores\",\n \"objective\": 0.10655,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number 2 raised to the power of the bin's index from the score, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n bin_indices = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (capacities - item)) * 0.3 - (np.sqrt(2) ** bin_indices * 0.2) + (item * np.log(capacities) ** 0.4)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the sum of the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the product of the bin's capacity and the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities + item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities * (capacities - item))**0.3)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.6) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, raised to the power of 0.4, and finally subtracting the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((1 / capacities) / (bins - item)**0.7) - (np.sqrt(used_counts)**2 * 0.2) + (item * np.log(capacities + item)**0.4) - (np.log((bins - item)**(1/3)) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that calculates the average of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / (bins - item))**0.5) - (np.sqrt(used_counts)**2 * 0.5) + (item * np.log(np.maximum(bins - item, 1))**0.3)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / remaining_capacities) - (used_counts * 0.2) + (item * np.log(bins + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the sum of the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the product of the bin's capacity and the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities + item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities * (capacities - item))**0.3)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.6) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified score function that takes into account the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.8) + (item * np.sqrt(capacities)**0.5)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (np.sqrt(capacities - item))**0.8) - (used_counts * 0.6) + (item * np.sqrt(capacities)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - used_counts + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / remaining_capacities) - (used_counts * 0.2) + (item * np.log(bins + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the sum of the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the product of the bin's capacity and the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities + item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities * (capacities - item))**0.3)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified score function that takes into account the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - (used_counts * 0.8) + (item * np.sqrt(capacities)**0.5)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.7, subtracting the number of times the bin has been used from the score, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.7) - used_counts + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item)**0.8) / (np.sqrt(bins - item)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.5, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.6) - (used_counts * 0.5) + (item * np.sqrt(capacities)**0.3)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-8\\n scores = (np.log(bins.astype(float) + epsilon) / ((bins - item) + epsilon)**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item)**0.8) / (np.sqrt(bins - item)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (capacities - item) * 0.5 - used_counts**2 * 0.3 + item * np.sqrt(capacities) * 0.4\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, subtracting the square root of the number of times the bin has been used from the score squared, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.9, instead of 0.8. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) - np.sqrt(used_counts) ** 2 + item * np.log(bins + item) * 0.9\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-8\\n scores = (np.log(bins.astype(float) + epsilon) / ((bins - item) + epsilon)**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: \\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.6.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.7 - np.sqrt(np.arange(len(bins))) ** 2 * 0.3 + item * np.log(bins + item) * 0.6\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins - item)**0.8) / (np.sqrt(bins - item)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities + 1) / (bins - item) * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (bins - item) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (capacities - item) * 0.5 - used_counts**2 * 0.3 + item * np.sqrt(capacities) * 0.4\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) - np.log(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, subtracting the square root of the number of times the bin has been used from the score squared, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.9, instead of 0.8. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) - np.sqrt(used_counts) ** 2 + item * np.log(bins + item) * 0.9\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n epsilon = 1e-8\\n scores = (np.log(bins.astype(float) + epsilon) / ((bins - item) + epsilon)**0.8) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log1p(capacities) / (bins - item) * 0.7) - (used_counts * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, subtracting the square root of the number of times the bin has been used from the score squared, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.9, instead of 0.8. \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) - np.sqrt(used_counts) ** 2 + item * np.log(bins + item) * 0.9\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n scores = (np.log1p(capacities) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate the score for each bin based on the current capacity and its relationship with the item size, as well as the number of times the bin has been used.\\n\\nNew Algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the bin's capacity, raised to the power of 0.2, and finally multiplying the score by the item size.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.sqrt(capacities) / (bins - item) * 0.7) - (np.arange(len(bins)) ** 2 * 0.3) + (item * np.log(capacities) ** 0.2) * item\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.8.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) / (bins - item) * 0.6 - np.sqrt(used_counts) ** 2 * 0.4 + item * np.log(bins + item) * 0.8\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n scores = (np.log1p(capacities) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log10(capacities) / (remaining_capacities) - (np.sqrt(used_counts) ** 2 * 0.3) \\n + (item * (remaining_capacities) ** 2)**0.2)\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) * 0.6 - np.sqrt(np.arange(len(bins))) ** 2 * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.6, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item)**0.8)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.5 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (np.log1p(bins) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that calculates the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size, raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.4, and adds the product of the item size and the natural logarithm of the bin's capacity raised to the power of 0.8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / ((bins - item) ** 0.6) - np.arange(len(bins)) * 0.4 + (item * np.log(bins)) ** 0.8\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the bin's capacity divided by the difference between the bin's capacity and the item size, subtracts the square of the number of times the bin has been used from the score, then adds the product of the item size and the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) - np.arange(len(bins))**2 + (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on the bin's capacity and the item size, adding the item size divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.6, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item)**0.8)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.5 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins.astype(float) - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(bins.astype(float)) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nBased on this backbone idea, my new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.5) - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(bins - item) * 0.1)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the highest preference score based on their rest capacity and the item size, and updates the rest capacity of the bin accordingly, until all items are assigned. The preference score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's rest capacity, a weight factor, and the number of times the bin has been used. The algorithm then updates the rest capacity of the chosen bin and repeats this process until all items are assigned, with the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_factor = 1.5\\n scores = (bins * weight_factor) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size plus 1, plus the number of times the bin has been used.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * (np.log(item + 1)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and adding the inverse of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (np.sqrt(remaining_capacities)) * 0.8 + (1 / (used_counts + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score, considering both the rest capacity and the number of items currently in each bin, in order to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = (item / (bins[bins != bins.max()] - item + 1)) * (bins[bins != bins.max()] - bins[bins != bins.max()] / np.count_nonzero(bins != bins.max()))\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square of the item size divided by the difference between the bin's capacity and the item size.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.6) - (used_counts ** 2 * 0.3) + ((item ** 2) / (bins - item))\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, plus the cube of the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / ((bins - item)**2 + np.arange(len(bins))**3)\\n return scores\",\n \"objective\": 0.04075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n max_capacity = np.max(bins)\\n scores[bins != max_capacity] = item / bins[bins != max_capacity]\\n return scores\",\n \"objective\": 0.04095,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that takes into account the difference between the logarithm of the current item and the logarithm of the rest capacities of bins, and the number of times each bin has been used. The score for each bin is calculated by subtracting the logarithm of the rest capacity from the logarithm of the bin's capacity, and then multiplying it by a factor of 0.5. Then the number of times the bin has been used is added to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n log_item = np.log(item)\\n log_rest_capacities = np.log(bins - item)\\n used_counts = np.arange(len(bins))\\n scores = (log_item - log_rest_capacities) * 0.5 + used_counts\\n return scores\",\n \"objective\": 0.04105,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculating scores for each bin based on their rest capacity and the item size.\\n\\nNew algorithm description: The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the product of the bin's current capacity and the item size divided by the difference between the bin's capacity and the item size, plus the square of the number of times the bin has been used.\\n\\nCode:\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item) + np.arange(len(bins)) ** 2\\n return scores\",\n \"objective\": 0.04115,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the given algorithms, the common backbone idea is to assign an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins.\\n\\nThe new algorithm assigns items to bins based on a score function that takes into account the bin's current capacity, the item's size, and the number of times the bin has been used, aiming to minimize the number of used bins.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n factor = 1.5 # Fixed value for the weight factor\\n scores = (bins * factor) / (bins - item + np.arange(len(bins))) # The score function is a combination of the bin's capacity, item size, and number of times used\\n return scores\",\n \"objective\": 0.04125,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n scores = (np.log1p(bins) / (bins - item) * 0.7) - (np.arange(len(bins)) * 0.3) + (item * (bins - item) ** 2)**0.2\\n return scores\",\n \"objective\": 0.00674,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the square of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.mean(bins.astype(float)) # Using mean of 'bins' as representative value\\n scores = (np.log(capacities) / (bins - item) * 0.7) - (np.sqrt(np.arange(len(bins))) ** 2 * 0.3) + (item * (bins - item) ** 2) ** 0.2\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that calculates the square root of the bin's current capacity divided by the product of the difference between the bin's capacity and the item size, raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.4, and adds the product of the item size and the natural logarithm of the bin's capacity raised to the power of 0.8.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / ((bins - item) ** 0.6) - np.arange(len(bins)) * 0.4 + (item * np.log(bins)) ** 0.8\\n return scores\",\n \"objective\": 0.00694,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the bin's capacity divided by the difference between the bin's capacity and the item size, subtracts the square of the number of times the bin has been used from the score, then adds the product of the item size and the square root of the bin's capacity.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item)) - np.arange(len(bins))**2 + (item * np.sqrt(bins))\\n return scores\",\n \"objective\": 0.00704,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on the bin's capacity and the item size, adding the item size divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + item / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\\"Algorithm Description\\\":\\nNew algorithm: My new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 1.2, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.8, and finally adding the square root of the bin's capacity raised to the power of 1.5.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.2 - np.arange(len(bins)) * 0.8 + np.sqrt(bins)**1.5\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = ((np.log(bins) / (bins - item)) ** 2 - np.sqrt(np.arange(len(bins))) ** 2) * 0.4 + item * np.log(bins + item) * 0.5\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm calculates a score for each bin based on a combination of the bin's capacity and the item size, the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins + np.log(bins) / (bins - item) * 0.3 - np.arange(len(bins))**2 * 0.2 + item * np.sqrt(bins) * 0.5\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the cube root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the square root of the bin's capacity, raised to the power of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(bins) / (bins - item) * 0.8) - (used_counts**2 * 0.2) + (item * np.sqrt(bins)**0.6)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) - np.arange(len(bins))**2 * 0.3 + item * np.sqrt(bins) * 0.4\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nThe new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.6, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.8, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item))**0.6) - (np.arange(len(bins)) * 0.8) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(1 / remaining_capacities) / np.sqrt(bins - item)) * 0.7 - (used_counts * 0.3) + (item * np.log(bins + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the ratio between the natural logarithm of the bin's current capacity and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n used_counts = np.arange(len(bins))\\n scores = (np.log(bins) / np.sqrt(bins - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(bins) * 0.4)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / np.sqrt(bins - item) - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins) ** 0.5\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the bin's capacity, multiplied by a factor of 0.3.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) * 0.6 - np.arange(len(bins)) * 0.2 + item * np.log(bins) * 0.3\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size raised to the power of 0.8, subtracts the number of times the bin has been used from the score multiplied by a factor of 0.6, and adds the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (np.log(bins.astype(float)) / (np.sqrt(bins - item)**0.8)) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.4)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (1/bins) / (bins - item)**1.5 - np.arange(len(bins)) * 0.8 + np.cbrt(bins)**2.5\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\n\\nMy new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.8, then subtracting the number of times the bin has been used from the score multiplied by a factor of 0.6, and finally adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item)**0.8 - np.arange(len(bins)) * 0.6 + item * np.sqrt(bins)**0.5\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity minus the item size, raised to the power of 0.8, divided by the square root of the difference between the bin's capacity and the item size, subtracting the number of times the bin has been used from the score, multiplied by a factor of 0.6, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item)**0.4 / np.sqrt(bins - item) - (np.arange(len(bins)) * 0.6) + (item * np.sqrt(bins)**0.5)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins.astype(float) - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(bins.astype(float)) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's remaining capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.2, and adding the number of times the bin has been used subtracted by 2 to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (remaining_capacities / np.sqrt(bins - item)) * 1.2 + (used_counts - 2)\\n return scores\",\n \"objective\": 0.02505,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the square of the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the cube root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities ** 2 / ((bins - item) ** 2) * 0.5) - ((np.cbrt(used_counts) ** 3) * 0.5) + (item * (np.cbrt(bins - item)) * 0.5)\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculate scores for each bin based on their rest capacity and the item size.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the square root of the bin's rest capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's rest capacity plus 1, and adding the reciprocal of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (np.sqrt(bins) / np.sqrt(bins - item)) * np.log(bins + 1) + (1 / (np.arange(len(bins)) + 1))\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description:\\nThe new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracted by the logarithm of the number of times the bin has been used, squared.\\n\\nPython Implementation:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / remaining_capacities) * 0.8 - np.log(used_counts + 1)**2\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm: The new algorithm assigns an item to the bin with the highest preference score based on their rest capacity and the item size, and updates the rest capacity of the bin accordingly, until all items are assigned. The preference score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the bin's capacity, plus the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * np.log(bins) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's rest capacity, a weight factor, and the number of times the bin has been used. The algorithm then updates the rest capacity of the chosen bin and repeats this process until all items are assigned, with the goal of minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weight_factor = 1.5\\n scores = (bins * weight_factor) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03894,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the logarithm of the item size plus 1, plus the number of times the bin has been used.\\n\\nHere is the implementation of the new algorithm in Python:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * (np.log1p(item)) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm assigns an item to the bin with the maximum score, considering the rest capacity of each bin, in order to minimize the number of used bins. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros_like(bins)\\n scores[bins != bins.max()] = item / (bins[bins != bins.max()] - item + 1)\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and adding the inverse of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (np.sqrt(remaining_capacities)) * 0.8 + (1 / (used_counts + 1))\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: Calculate scores for each bin based on their rest capacity and the item size.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the cube of the difference between the bin's capacity and the item size, multiplied by a factor of 1.5, and adding the reciprocal of the number of times the bin has been used to the score.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / ((remaining_capacities)**3) * 1.5 + (1 / (used_counts + 1))\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.sqrt(bins) / (bins - item) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.9, and subtracting the square root of the number of times the bin has been used from the score.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (remaining_capacities) * 0.9 - np.sqrt(used_counts)\\n return scores\",\n \"objective\": 0.03954,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the score for each bin is calculated as the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, plus the square root of the number of times the bin has been used.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.log(bins) / (bins - item) + np.sqrt(np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate scores for each bin based on their rest capacity and the item size. \\n\\nBased on this backbone idea, the new algorithm assigns an item to the bin with the maximum score and updates the rest capacity of the bin accordingly, until all items are assigned. The score for each bin is calculated as the bin's current capacity multiplied by the item size divided by the difference between the bin's capacity and the item size, plus the number of times the bin has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins * item) / (bins - item + 1) + np.arange(len(bins))\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function, where each bin is assigned the item with the maximum score, and empty bins with maximum capacity are not used; the goal is to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and adding the square root of the number of times the bin has been used to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = np.log(capacities) / (remaining_capacities) * 0.7 + np.sqrt(used_counts)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm assigns items to bins based on a modified score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the square root of the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.3) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.2) - (np.sqrt(item * (np.cbrt(bins - item))) * 0.1)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(capacities * item)) * 0.1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the score for each bin by multiplying the bin's current capacity divided by the difference between the bin's capacity and the item size, by a factor of 1.2, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and finally multiplying the score by a random factor between 0.9 and 1.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n random_factors = np.random.uniform(0.9, 1.1, len(bins))\\n scores = (capacities / (bins - item)) * 1.2 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3) * random_factors\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(bins - item)) * 0.4)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the item size multiplied by the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.cbrt(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 1.5) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: The new algorithm assigns items to bins based on a score function that considers the exponential of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 2, subtracting the exponent of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the exponential of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.exp(capacities) / np.sqrt(bins - item) ** 2 * 2) - (np.exp(used_counts) ** 2 * 0.5) + (item * np.exp(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.1, then adding the product of the item size and the logarithm of the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.8) - (np.sqrt(used_counts) ** 2 * 0.1) + (item * np.log(np.sqrt(bins - item)) * 0.4)\\n return scores\",\n \"objective\": 0.01429,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the square root of the bin's remaining capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the natural logarithm of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the fourth root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and finally subtracting the square root of the product of the item size and the fourth root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(remaining_capacities) / (bins - item) * 0.5) - (np.log(used_counts) ** 2 * 0.4) + (item * (bins - item) ** (1/4) * 0.3) - (np.sqrt(item * (bins - item) ** (1/4)) * 0.2)\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the score for each bin by multiplying the bin's current capacity divided by the difference between the bin's capacity and the item size, by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.1, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.1) + (item * (np.cbrt(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.01942,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The algorithms calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: Assign items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, adding the item size multiplied by the log of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2, and finally adding the square root of the log base 10 of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item)) * 0.3 - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.2) + (np.sqrt(np.log10(capacities + item)) * 0.1)\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\\n\\n# New algorithm - Changing the parameter settings of the score function\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.3) - (np.sqrt(used_counts) ** 3 * 0.7) + (item * (np.log(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.02234,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 3.0, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 3.0) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins - item) * 0.7)\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns an item to the bin with the maximum score, which is calculated based on the bin's remaining capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.2, and adding the number of times the bin has been used subtracted by 2 to the score.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (remaining_capacities / np.sqrt(bins - item)) * 1.2 + (used_counts - 2)\\n return scores\",\n \"objective\": 0.02505,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm assigns items to bins based on a score function that considers the square of the bin's current capacity divided by the square of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the cube root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities ** 2 / ((bins - item) ** 2) * 0.5) - ((np.cbrt(used_counts) ** 3) * 0.5) + (item * (np.cbrt(bins - item)) * 0.5)\\n return scores\",\n \"objective\": 0.02586,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm:\\nThe new algorithm assigns an item to the bin with the highest preference score based on a modified formula that incorporates the rest capacity of the bin, the item size, and a weight factor, and updates the rest capacity of the bin accordingly, until all items are assigned.\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef score(item, bins):\\n scores = (bins / (bins - item + 1)) * np.log(bins) + np.arange(len(bins)) + 0.5 * bins\\n return scores\",\n \"objective\": 0.02616,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.5) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.8) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log((bins - item) ** (1/3)) * 0.5)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm assigns items to bins based on a score function that considers the logarithm of the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size squared, multiplied by a factor of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(np.sqrt(capacities)) / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * np.log((capacities + item) ** 2) * 0.6)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / remaining_capacities) - used_counts + (item * (np.cbrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity, multiplied by a factor of 0.5, and finally, subtracting the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.8) - ((np.sqrt(used_counts) ** 2) * 0.2) + (item * np.log(capacities) * 0.5) - (item * np.log(capacities * item) * 0.1)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(capacities * item)) * 0.1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the score for each bin by multiplying the bin's current capacity divided by the difference between the bin's capacity and the item size, by a factor of 1.2, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the cubic root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and finally multiplying the score by a random factor between 0.9 and 1.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n random_factors = np.random.uniform(0.9, 1.1, len(bins))\\n scores = (capacities / (bins - item)) * 1.2 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3) * random_factors\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(bins - item)) * 0.4)\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the item size multiplied by the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.cbrt(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 1.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 1.5) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01137,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: Assigning items to bins based on a score function that considers the current capacity of the bin, the difference between the bin's capacity and the item size, and the number of times the bin has been used.\\n\\nNew algorithm: The new algorithm assigns items to bins based on a score function that considers the exponential of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 2, subtracting the exponent of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the exponential of the difference between the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.exp(capacities) / np.sqrt(bins - item) ** 2 * 2) - (np.exp(used_counts) ** 2 * 0.5) + (item * np.exp(bins - item) * 0.3)\\n return scores\",\n \"objective\": 0.01227,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that calculates the sum of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by the natural logarithm of the bin's current capacity divided by the item size, subtracted by the square root of the difference between the bin's capacity and the item size, multiplied by the number of times the bin has been used, and added to the product of the item size and the hyperbolic tangent of the bin's current capacity divided by the item size, multiplied by the natural logarithm of the difference between the bin's capacity and the item size.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item)) * np.log(capacities / item) - np.sqrt(bins - item) * used_counts + (item * np.tanh(capacities / item) * np.log(bins - item))\\n return scores\",\n \"objective\": 0.01238,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - used_counts + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3. It also takes into account the square root of the item size multiplied by the logarithm of the maximum capacity of the bins, divided by the log base 10 of the bin's capacity plus one, multiplied by a factor of 0.1.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3) + (np.sqrt(item) * np.log(np.max(capacities)) / (np.log10(capacities + 1))) * 0.1\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.5) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.8) - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log((bins - item) ** (1/3)) * 0.5)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item) * 0.2) - (np.sqrt(used_counts) ** 2 * 0.6) + (item * (np.cbrt(bins - item)) * 0.2)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n \\n # new algorithm\\n scores = (capacities / (bins - item)) * 0.8 + (item / (bins - item)) * 0.1 - (used_counts ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3)\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / remaining_capacities) - used_counts + (item * np.log(bins - item))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm assigns items to bins based on a score function that considers the logarithm of the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size squared, multiplied by a factor of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(np.sqrt(capacities)) / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * np.log((capacities + item) ** 2) * 0.6)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.6, then adding the product of the item size and the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / remaining_capacities) - used_counts + (item * (np.cbrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity, multiplied by a factor of 0.5, and finally, subtracting the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.8) - ((np.sqrt(used_counts) ** 2) * 0.2) + (item * np.log(capacities) * 0.5) - (item * np.log(capacities * item) * 0.1)\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the product of the bin's capacity and the item size, multiplied by a factor of 0.1.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((np.log(capacities) / (bins - item)) * 0.6) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * (np.log(capacities * item)) * 0.1)\\n return scores\",\n \"objective\": 0.00996,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.6 - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3. It also takes into account the square root of the item size multiplied by the logarithm of the maximum capacity of the bins, divided by the log base 10 of the bin's capacity plus one, multiplied by a factor of 0.1.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3) + (np.sqrt(item) * np.log(np.max(capacities)) / (np.log10(capacities + 1))) * 0.1\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the product of the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2) - (np.log(capacities + item) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.15 instead of 0.2, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.6) - (used_counts * 0.15) + (item * np.sqrt(capacities) ** 0.25)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a revised scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.2 instead of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.5) - (used_counts * 0.2) + (item * np.sqrt(capacities) ** 0.3)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n \\n # new algorithm\\n scores = (capacities / (bins - item)) * 0.8 + (item / (bins - item)) * 0.1 - (used_counts ** 2 * 0.5) + (item * (np.cbrt(bins - item)) * 0.3)\\n \\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the weights of the different score components to prioritize different factors in the scoring. It uses a combination of square roots and logarithms to calculate the scores, and the weights for each component have been modified to alter their impact on the overall score calculation.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / remaining_capacities) - used_counts + (item * np.log(bins - item))\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Based on the backbone idea, the new algorithm assigns items to bins based on a score function that considers the logarithm of the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size squared, multiplied by a factor of 0.6.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(np.sqrt(capacities)) / (capacities - item)) * 0.4 - (np.sqrt(used_counts) ** 2 * 0.5) + (item * np.log((capacities + item) ** 2) * 0.6)\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item)) * 0.6 - (np.sqrt(np.arange(len(bins))) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number 2 raised to the power of the bin's index from the score, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n bin_indices = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (capacities - item)) * 0.3 - (np.sqrt(2) ** bin_indices * 0.2) + (item * np.log(capacities) ** 0.4)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3. It also takes into account the square root of the item size multiplied by the logarithm of the maximum capacity of the bins, divided by the log base 10 of the bin's capacity plus one, multiplied by a factor of 0.1.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / remaining_capacities) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(bins + item) * 0.3) + (np.sqrt(item) * np.log(np.max(bins)) / (np.log10(bins + 1))) * 0.1\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.6 - (np.sqrt(used_counts) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the logarithm of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and twice the item size, raised to the power of 0.4.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / ((capacities - item) ** 0.5)) - (np.log(used_counts + 1) ** 2 * 0.2) + (item * np.log(capacities + 2 * item) ** 0.4)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the product of the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2) - (np.log(capacities + item) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (bins - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a modified scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.6, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.15 instead of 0.2, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.25.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.6) - (used_counts * 0.15) + (item * np.sqrt(capacities) ** 0.25)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / (capacities - item)) - (used_counts * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a revised scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.2 instead of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.5) - (used_counts * 0.2) + (item * np.sqrt(capacities) ** 0.3)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n scores = (np.log(capacities) / (bins - item)) * 0.6 - (np.sqrt(np.arange(len(bins))) ** 2 * 0.4) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The existing algorithms calculate a score for each bin based on a combination of the bin's capacity and the item size, the number of times the bin has been used, and other mathematical functions.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a score function that considers the natural logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square of the number of times the bin has been used from the score, multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity, multiplied by a factor of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) * 0.5) - (used_counts**2 * 0.3) + (item * np.sqrt(capacities) * 0.4)\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, subtracting the square root of the number 2 raised to the power of the bin's index from the score, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the bin's capacity raised to the power of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n bin_indices = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (capacities - item)) * 0.3 - (np.sqrt(2) ** bin_indices * 0.2) + (item * np.log(capacities) ** 0.4)\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.3.\\n\\nPython implementation:\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.3)\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the implementation in Python:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (0.6 / (capacities - item + 1e-6)) - (used_counts * 0.4) + (item * np.log(capacities + item + 1e-6) * 0.5)\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the logarithm of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and twice the item size, raised to the power of 0.4.\\n\\n```Python\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / ((capacities - item) ** 0.5)) - (np.log(used_counts + 1) ** 2 * 0.2) + (item * np.log(capacities + 2 * item) ** 0.4)\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.3, and subtracting the square of the number of times the bin has been used from the score, multiplied by another factor of 0.7, then adding the product of the item size and the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = np.maximum(capacities - item, 0)\\n used_counts = np.arange(len(bins))\\n scores = (1/capacities) / remaining_capacities - used_counts**2 + (item * (np.sqrt(capacities - item)))\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.7 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.5)\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm assigns items to bins based on a score function that considers the product of the bin's current capacity divided by the difference between the bin's capacity and the item size, squared, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.3, then adding the square root of the item size multiplied by the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (capacities / (bins - item) ** 2 * 0.7) - (np.sqrt(used_counts) ** 2 * 0.3) + (np.sqrt(item) * np.log(bins - item) * 0.5)\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea: The provided algorithms calculate scores for each bin based on the bin's capacity, the item size, and the number of times the bin has been used.\\n\\nNew algorithm description: My new algorithm assigns items to bins based on a scoring function that considers the product of the logarithm of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the cube root of the difference between the bin's capacity and the item size, multiplied by a factor of 0.2, and finally subtracting the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / np.sqrt(bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log((bins - item) ** (1/3)) * 0.2) - (np.log(capacities + item) * 0.1)\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm assigns items to bins based on a score function that calculates the average of the bin's current capacity divided by the difference between the bin's capacity and the item size, raised to the power of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / (bins - item))**0.5) - (np.sqrt(used_counts)**2 * 0.5) + (item * np.log(np.maximum(bins - item, 1))**0.3)\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nDescription: The new algorithm assigns items to bins based on a score function that considers the cubic root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, and subtracting the square root of the number of times the bin has been used from the score, squared, multiplied by a factor of 0.5, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, multiplied by a factor of 0.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.cbrt(capacities) / (bins - item) * 0.4) - (np.sqrt(used_counts) ** 2 * 0.5) + (item * (np.log(bins - item)) * 0.1)\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that calculates the product of the bin's current capacity divided by the square root of the difference between the bin's capacity and the item size, raised to the power of 0.3, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.5.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = ((capacities / np.sqrt(bins - item))**0.3) - (np.sqrt(used_counts)**2 * 0.4) + (item * np.log(np.maximum(bins - item, 1))**0.5)\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.8, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.8 - (np.sqrt(used_counts) ** 2 * 0.2) + (item * np.log(capacities + item) * 0.4)\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.5, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (capacities - item)) * 0.5 - (np.sqrt(used_counts) ** 2 * 0.3) + (item * np.log(capacities + item) * 0.2)\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the square root of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.6, subtracting the cube root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.4, then adding the product of the item size and the logarithm of the difference between the bin's capacity and the item size, raised to the power of 0.2.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.sqrt(capacities) / (bins - item) * 0.6) - (np.cbrt(used_counts) ** 2 * 0.4) + (item * np.log((bins - item))**0.2)\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.4, subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.2, then adding the product of the item size and the natural logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.4.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacities = bins - item\\n used_counts = np.arange(len(bins))\\n scores = (0.4 / remaining_capacities) - (used_counts * 0.2) + (item * np.log(bins + item) * 0.4)\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a score function that considers the logarithm of the bin's current capacity divided by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.4.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item)**0.5) - (used_counts * 0.3) + (item * np.sqrt(capacities)**0.4)\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: My new algorithm assigns items to bins based on a revised scoring function. The score for each bin is calculated by dividing the logarithm of the bin's current capacity by the difference between the bin's capacity and the item size raised to the power of 0.5, subtracting the number of times the bin has been used from the score multiplied by a factor of 0.2 instead of 0.3, then adding the product of the item size and the square root of the bin's capacity raised to the power of 0.3.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = np.array(bins, dtype=float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (np.log(capacities) / (capacities - item) ** 0.5) - (used_counts * 0.2) + (item * np.sqrt(capacities) ** 0.3)\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to calculate a score for each bin based on its capacity, the item size, and the number of times the bin has been used.\\n\\nThe new algorithm assigns items to bins based on a score function that considers the inverse of the bin's current capacity divided by the difference between the bin's capacity and the item size, multiplied by a factor of 0.7, and subtracting the square root of the number of times the bin has been used from the score squared, multiplied by a factor of 0.3, then adding the product of the item size and the logarithm of the sum of the bin's capacity and the item size, multiplied by a factor of 0.5.\\n\\nHere is the Python implementation:\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n capacities = bins.astype(float)\\n remaining_capacities = capacities - item\\n used_counts = np.arange(len(bins))\\n scores = (1 / (remaining_capacities + 1e-6)) * 0.7 - (used_counts * 0.3) + (item * np.log(np.maximum(capacities, item) + 1) * 0.5)\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nMy idea is to create a score function that takes into account the current rest capacities of the bins and the size of the item to be assigned. The main steps involve calculating the score for each bin based on its rest capacity, with a penalty for bins that are at maximum capacity, and then returning the scores for assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (max_capacity - bins) - (bins == max_capacity) * item\\n return scores\",\n \"objective\": 0.03984,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe main idea is to assign a score to each bin based on its remaining capacity and the size of the current item. The score will be calculated using a novel formula that takes into account both the remaining capacity and the difference between the bin capacity and the item size. The main steps include calculating the score for each bin using the novel formula, and returning the scores for each bin for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -1\\n elif bins[i] > item:\\n scores[i] = bins[i] - item\\n else:\\n scores[i] = -1\\n return scores\",\n \"objective\": 1.51534,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe score function will calculate the scores for each bin based on the rest capacity and the size of the item to be assigned. The main steps include calculating the difference between the rest capacity of each bin and the item size, penalizing bins with maximum capacity, and updating the scores with additional criteria to favor more efficient bin usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n\\n for i in range(len(bins)):\\n if bins[i] == item:\\n scores[i] = -float('inf')\\n else:\\n scores[i] = bins[i] - item\\n \\n max_capacity = max(bins)\\n max_count = list(bins).count(max_capacity)\\n if max_count == 1:\\n max_index = np.argmax(bins)\\n scores[max_index] -= item\\n \\n return scores\",\n \"objective\": 1.51484,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates the score for each bin based on a combination of the rest capacity and a penalty for using a bin. The main steps involve calculating the score for each bin by taking into account the rest capacity and penalizing the bins with the maximum capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n penalty = 1 - (bins/max_capacity) # Penalize bins with maximum capacity\\n scores = (bins - item) * penalty # Calculate scores based on rest capacity and penalty\\n return scores\",\n \"objective\": 0.13211,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI propose a novel score function that calculates the scores for the bins based on a combination of their rest capacity and a penalty factor for fully utilized bins. The main steps involve calculating the base score for each bin as the difference between rest capacity and item size, and then applying a penalty factor if the rest capacity equals the maximum capacity. The final scores will be the combination of the base scores and the penalty scores.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n base_scores = bins - item\\n penalty_scores = np.where(bins == max(bins), -item, 0)\\n scores = base_scores + penalty_scores\\n return scores\",\n \"objective\": 0.32559,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates the scores for each bin based on the remaining capacity and the difference between the bin capacity and the item size. The scores will be higher for bins with more remaining capacity and smaller difference between the capacity and the item size. Then, I will implement this in Python as a function named score that accepts 'item' and 'bins' as inputs and returns 'scores' as the output.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n max_capacity = np.max(bins)\\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = 0\\n else:\\n scores[i] = bins[i] - item + (max_capacity - bins[i])\\n return scores\",\n \"objective\": 0.04226,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nIdea: \\nThe novel score function will calculate the scores for each bin based on their remaining capacity and the size of the current item. It will penalize bins that are close to reaching their maximum capacity in order to minimize the number of used bins.\\n\\nPython function:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins) \\n scores = (max_capacity - bins) / max_capacity - (max_capacity - bins - item) / max_capacity\\n return scores\",\n \"objective\": 0.06812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates the scores for each bin based on their rest capacity, with consideration of the maximum capacity constraint. The main steps include identifying the bins with enough capacity, computing their scores based on the rest capacity, and penalizing the bins at maximum capacity by assigning them lower scores. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.maximum(bins - item, 0) / (1 + (bins == bins.max()))\\n return scores\",\n \"objective\": 0.84787,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function based on the remaining capacity of each bin, considering both the absolute capacity and the proximity to the item size. The main steps include calculating the absolute remaining capacity, normalizing it, and then adjusting the scores based on the proximity to the item size. This function aims to provide a more balanced and efficient assignment of items to bins, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = max_capacity - bins\\n normalized_capacity = remaining_capacity / max_capacity\\n proximity_adjustment = np.abs(bins - item) / item\\n scores = normalized_capacity * (1 - proximity_adjustment)\\n return scores\",\n \"objective\": 0.03803,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nIdea: The score function will calculate the scores for each bin based on the rest capacity and the efficiency of space utilization, resulting in a more complex and efficient scoring system.\\n\\nPython function:\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04095,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI propose a score function that ranks the feasible bins based on a combination of their rest capacity and the difference between their rest capacity and the current item size. The main steps include calculating the difference between the rest capacity and the item size for each bin, and then applying a weighted sum to obtain the final scores for assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n differences = bins - item\\n scores = (bins / (differences + 1)) * (differences > 0)\\n return scores\",\n \"objective\": 0.05071,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function that calculates scores for each bin based on their remaining capacity and the size of the current item. First, I will calculate the available capacity for each bin by subtracting the item size from the rest capacities. Then, I will design a scoring mechanism that penalizes bins with higher remaining capacity, encouraging the use of bins with closer capacity to the item size. Finally, I will implement this scoring function in Python using NumPy for efficient array operations and return the scores for each bin for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n available_capacity = bins - item\\n penalty = 1 / (1 + np.exp(available_capacity)) # Penalize bins with higher remaining capacity\\n scores = 1 - penalty # Invert penalties to get scores\\n return scores\",\n \"objective\": 0.79404,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to calculate the score function for each bin by considering the ratio of remaining capacity to the item size, and then penalize the bins which are close to full capacity in order to minimize the number of used bins. In Python, I will implement this as a function named score, which will take 'item' and 'bins' as inputs and return 'scores' as the output. I will ensure self-consistency by validating the inputs and outputs and implementing the scoring logic with Numpy arrays for efficient computation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.9, utilization_ratio, 1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.04045,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to create a scoring function that takes into account the rest capacities of the bins and assign a higher score to the bins with larger capacities. The main steps include calculating the ratio of item size to bin capacity, taking the logarithm of the ratios to ensure a balanced scoring, and finally assigning the scores to the bins to prioritize usage of the bins with larger capacities. \\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n scores = 1 / log_ratios\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ratios = item / bins\\n log_ratios = np.log(ratios)\\n scores = 1 / log_ratios\\n return scores\",\n \"objective\": 0.89597,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI will design a score function that calculates the scores for each bin based on their rest capacity and the size of the current item. The score will be higher for bins with more capacity remaining, and the function will also consider minimizing the number of used bins. In each step, the item will be assigned to the bin with the maximum score.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / (1 + np.arange(len(bins)))\\n return scores\",\n \"objective\": 0.10715,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nI will compute the score for each bin by taking the ratio of item size to the rest capacity of the bin, and then I will apply a penalty to the scores of bins with maximum capacity to avoid using them unnecessarily. Then, I will return the computed scores as the output. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = item / bins\\n max_capacity = np.max(bins)\\n penalty = (max_capacity - bins) / max_capacity\\n scores -= penalty\\n return scores\",\n \"objective\": 0.94074,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel score function will calculate the scores for each bin based on their current rest capacity and the size of the item to be assigned. The main steps include determining the feasible bins, calculating the scores based on a complex formula involving the rest capacity and item size, and returning the scores for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Determine the feasible bins\\n feasible_bins = bins[bins >= item]\\n \\n # Calculate scores based on a complex formula\\n scores = (feasible_bins - item) / (feasible_bins * np.log(feasible_bins))\\n \\n return scores\",\n \"objective\": 1.38193,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy novel score function first calculates the available capacity in each bin after the item is assigned, then computes a weighted score for each bin based on the remaining capacity, priority of the bin, and other factors. Finally, it returns the scores for each bin to determine the optimal assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n # Calculate available capacities in each bin\\n avail_capacity = bins - item\\n max_capacity = np.max(bins)\\n \\n # Compute weighted scores based on remaining capacity and other factors\\n scores = (1 - (avail_capacity / max_capacity)) * (1 / (1 + np.exp(-0.5 * avail_capacity))) * np.random.rand(len(bins))\\n return scores\",\n \"objective\": 0.08401,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nMy novel score function will calculate the scores for each bin based on their remaining capacities and the size of the current item. First, it will filter out the bins with exactly the same capacity as the item, and then calculate the scores for the rest of the bins by considering both the ratio of remaining capacity to item size and the overall utilization of the bin. The higher the score, the more suitable the bin will be for assigning the item.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n valid_bins = bins[bins != item] # Remove bins with exactly the same capacity as the item\\n scores = (valid_bins - item) / item # Calculate scores based on remaining capacity and item size\\n scores -= np.log(1 + 1/valid_bins) # Consider overall utilization of the bin\\n return scores\",\n \"objective\": 0.08693,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe score function will calculate the scores for each bin based on their rest capacities and the size of the current item. The main steps include calculating the ratio of rest capacity to item size for each bin, penalizing bins with maximum capacity, and normalizing the scores to ensure self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = (bins - item) / item\\n scores[bins == np.max(bins)] -= 1\\n scores = np.maximum(scores, 0) / np.sum(np.maximum(scores, 0))\\n return scores\",\n \"objective\": 0.32659,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins, using a different penalty calculation method and a modified form of the score calculation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins), 0, -1)\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function based on the remaining capacity of each bin, considering both the absolute capacity and the proximity to the item size. The main steps include calculating the absolute remaining capacity, normalizing it, and then adjusting the scores based on the proximity to the item size. This function aims to provide a more balanced and efficient assignment of items to bins, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = max_capacity - bins\\n normalized_capacity = remaining_capacity / max_capacity\\n proximity_adjustment = np.abs(bins - item) / item\\n scores = normalized_capacity * (1 - proximity_adjustment)\\n return scores\",\n \"objective\": 0.03803,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins, using a penalty calculation method involving the square of the index and a modified form of the score calculation.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(1, len(bins) + 1)\\n scores = bins / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"scores = bins / (bins - item)**2 - np.arange(len(bins))**2\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = bins / (bins - item)**2 - np.arange(len(bins))**2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a linear priority of the bin, where the priority is set to the index of the bin.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and the priority of the bin based on its index, resulting in a more linear and index-based scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / np.arange(1, len(bins) + 1)\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for bins with a capacity below a certain threshold, encouraging the utilization of higher capacity bins, using a novel penalty calculation method and a modified form of the score calculation.\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins))) # New penalty calculation method\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n penalty[bins < threshold] *= 2 # Apply penalty for bins below the threshold\\n scores = bins / (bins - item + 0.1) - penalty # Modified score calculation\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins)))\\n threshold = 0.2 * bins.max()\\n penalty[bins < threshold] *= 2\\n scores = bins / (bins - item + 0.1) - penalty\\n scores -= np.where(bins == bins.max(), np.inf, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and the priority of the bin. The priority of each bin will be set to 1/2 raised to the power of its index, resulting in a exponential and index-based scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / 2 ** np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03944,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for bins that are closer to full capacity, promoting the utilization of lower index bins and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.log(np.arange(2, len(bins) + 2)) # Apply penalty based on the logarithm of the bin index\\n utilization_ratio = 1 - (bins - item) / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.95, utilization_ratio, 1) # Penalize bins close to full capacity\\n scores = penalized_utilization_ratio * penalty # Calculate scores based on penalized utilization ratio and penalty\\n return scores\",\n \"objective\": 0.03964,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm will calculate the score function for each bin by considering the ratio of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity in order to minimize the number of used bins. It will be implemented in Python as a function named score, which will take 'item' and 'bins' as inputs and return 'scores' as the output. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = item / remaining_capacity\\n penalized_utilization_ratio = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.03974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm will assign scores to each bin based on the inverse of the remaining capacities, penalizing bins with higher remaining capacities and ensuring self-consistency without a random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = 1 / (1 + bins)\\n return scores\",\n \"objective\": 0.03984,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the scores for each bin based on the reciprocal of the difference between the remaining capacity of the bin and the item size, and then penalize the bins which are close to full capacity, ensuring self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to calculate the score function for each bin by considering the ratio of remaining capacity to the item size, and then penalize the bins which are close to full capacity in order to minimize the number of used bins. In Python, I will implement this as a function named score, which will take 'item' and 'bins' as inputs and return 'scores' as the output. I will ensure self-consistency by validating the inputs and outputs and implementing the scoring logic with Numpy arrays for efficient computation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.9, utilization_ratio, 1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.04045,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nIdea: The score function will calculate the scores for each bin based on the rest capacity and the efficiency of space utilization, resulting in a more complex and efficient scoring system.\\n\\nPython function:\\n\\n```python\\nimport numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n efficiency = (bins - item) / bins\\n scores = (efficiency * bins) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.04095,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nThe new algorithm will assign scores to each bin based on the rank of the remaining capacities, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n ranks = np.argsort(bins)\\n penalized_ranks = np.where(bins >= 0.9 * np.max(bins), np.inf, ranks)\\n scores = 1 / (1 + penalized_ranks)\\n return scores\",\n \"objective\": 0.04175,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new score function will calculate the score for each bin based on the ratio of the remaining capacity of the bin to the size of the current item, with an added penalty for bins that are at maximum capacity and prioritize bins with lower index values.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = (bins / item) - (bins == max_capacity) * item - np.arange(len(bins))\\n return scores\",\n \"objective\": 0.04206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated by taking the ratio of the remaining capacity of each bin to the item size, with a penalty applied for bins that are closer to full capacity, ensuring efficient assignment and minimal usage of bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity_ratio = bins / item\\n penalized_remaining_capacity_ratio = np.where(remaining_capacity_ratio < 0.95, remaining_capacity_ratio, 1)\\n scores = penalized_remaining_capacity_ratio\\n return scores\",\n \"objective\": 0.04226,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new score function will calculate the score for each bin by considering the ratio of remaining capacity to the item size and penalizing bins with close to full capacity, using a different threshold value for penalization compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n penalized_utilization_ratio = np.where(utilization_ratio < 0.8, utilization_ratio, 1)\\n scores = penalized_utilization_ratio\\n return scores\",\n \"objective\": 0.04236,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a weighted combination of the utilization ratio, a modified exponential decay factor, and a dynamic adjustment to assign scores to each bin and minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n decay_factor = np.exp(-(bins - item)**2)\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (item * 1.5) / (np.exp(bins - item) + 0.5) * decay_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the utilization ratio, a novel dynamic adjustment, and a non-linearly decaying factor, incorporating a different parameter setting to facilitate the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1.5)) + 0.4)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.7) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, item size, and utilization ratio to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n adjustment_factor = (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1)\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), adjustment_factor + 0.8, adjustment_factor + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a modified scoring function based on the remaining capacity of the bins, item size, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.5, (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a modified scoring function based on the remaining capacity of the bins, item size, and a linearly decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm uses a scoring function with parameters such as utilization ratio, dynamic adjustment, and a linearly decaying factor, calculated using different parameter settings, to assign scores to each bin based on their remaining capacity, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms aim to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins, using a scoring function based on utilization ratio, dynamic adjustment, and an exponentially decaying factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a weighted combination of the utilization ratio, a modified exponential decay factor, and a dynamic adjustment to assign scores to each bin and minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (item * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-(bins - item)**2) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.85, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the utilization ratio, a unique dynamic adjustment, and a non-linearly decaying factor with a customized weighting factor to facilitate the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a modified scoring function based on the remaining capacity of the bins, item size, and a linearly decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n static_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm assigns scores to each bin based on the utilization ratio, a unique dynamic adjustment, and a non-linearly decaying factor with a customized weighting factor to facilitate the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes a novel combination of the utilization ratio, dynamic adjustment, and a logarithmically decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm utilizes the concept of bin utilization ratio and dynamic adjustment, incorporating a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.6) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins) / (np.exp(bins - item) + 1) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on a modified utilization ratio, a dynamic adjustment factor, and a linearly increasing factor to facilitate item assignment. \\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins) / (np.exp(bins - item) + 1) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a linear combination of the utilization ratio, a modified dynamic adjustment, and a decaying exponential function to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 4)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1))\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The common backbone idea in the provided algorithms is to assign scores to each bin based on a combination of the item size, remaining capacity of the bins, utilization ratio, dynamic adjustment, and an exponentially decaying factor to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.9, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on a modified utilization ratio, a dynamic adjustment factor, and a linearly increasing factor to facilitate item assignment. \\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm incorporates a utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.6) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a non-linear combination of trigonometric functions and a custom dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), 1.2 * np.sin(bins * np.pi / item) + 0.7, 1.1 * np.cos(bins * np.pi / item) + 0.5)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1))\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and a custom dynamic adjustment with an enhanced exponentially decaying factor to assign scores to each bin for item assignment, aiming to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment. The main parameters are utilization ratio, adjust, and linearly decaying factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.7) / (np.exp(bins - item) + 0.6) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on a modified utilization ratio, a dynamic adjustment factor, and a linearly increasing factor to facilitate item assignment. \\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-(bins - item)**2) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm incorporates a utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.6) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a non-linear combination of trigonometric functions and a custom dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), 1.2 * np.sin(bins * np.pi / item) + 0.7, 1.1 * np.cos(bins * np.pi / item) + 0.5)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1))\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff) + 0.8, (1 - diff / bins) * np.sqrt(diff) + 0.3)\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 0.5) + 0.3)\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is based on a combination of item size, remaining bin capacity, a novel weighted dynamic adjustment, and a modified decaying factor to assign scores to each bin, with the aim to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n weight = np.sqrt((bins - item) + 1)\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * weight + 0.8, (1 - diff / bins) * weight + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm incorporates a combination of utilization ratio, a modified exponential decay factor, and a dynamic adjustment based on the ratio of item size to bin capacity to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), utilization_ratio * np.sqrt(bins - item + 2) + 0.9, utilization_ratio * np.sqrt(bins - item + 1) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins / 2) / (np.exp(diff / 2) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin using a combination of the utilization ratio, a dynamic adjustment, and a non-linear decay factor to optimize item distribution and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (item * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm incorporates a utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins. It uses a weighted combination of these factors to calculate the scores for bin assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, incorporating a penalty for the deviation from the average capacity of all bins, and also considering the absolute difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity)\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.2 * bins.max() # Penalty for close to full capacity\\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 1)\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will use the concept of geometric series priority, where the score function will be calculated based on the geometric series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 2 ** np.arange(len(bins)) # Geometric series priority\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = priority / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of the bin, incorporating a penalty for bins with remaining capacity close to full, and further adjusting the scores based on the index of the bins in a non-linear manner, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.log(bins) - (bins - item < threshold) * 2 - np.sqrt(bin_indexes) ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilizing a modified priority calculation and penalty method based on remaining bin capacity to ensure self-consistency and avoid randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(1, len(bins) + 1) ** 2 # Modified priority calculation\\n threshold = 0.3 * bins.max()\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = bins / (bins - item) * priority - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Calculate the scores for each bin based on the reciprocal of the difference between the remaining capacity of the bin and the item size, and then penalize the bins which are close to full capacity, ensuring self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 / (bins - item)\\n scores = np.maximum(utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03763,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03793,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy idea is to design a score function based on the remaining capacity of each bin, considering both the absolute capacity and the proximity to the item size. The main steps include calculating the absolute remaining capacity, normalizing it, and then adjusting the scores based on the proximity to the item size. This function aims to provide a more balanced and efficient assignment of items to bins, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n remaining_capacity = max_capacity - bins\\n normalized_capacity = remaining_capacity / max_capacity\\n proximity_adjustment = np.abs(bins - item) / item\\n scores = normalized_capacity * (1 - proximity_adjustment)\\n return scores\",\n \"objective\": 0.03803,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for higher index bins to encourage the utilization of lower index bins, utilizing a different penalty calculation method and a modified form of the score calculation.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins), 0, -1) ** 2\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03813,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will use the concept of exponential priority, where the score function will be calculated based on the exponential of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = np.exp(priority) / (bins - item)\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a penalty based on the square of the index of the bin, ensuring a unique scoring system with emphasis on lower index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03833,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on a weighted combination of the item size and the remaining capacity of the bin, incorporating a penalty for bins close to full capacity, ensuring self-consistency and promoting balanced utilization of all bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n weights = np.arange(1, len(bins) + 1) ** 2 # Weighted combination of index values\\n utilization_ratio = item / (bins - item) # Relationship between item size and remaining capacity\\n threshold = 0.3 * bins.max()\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = utilization_ratio * weights - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03843,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a penalty based on the square of the index of the bin, ensuring a unique scoring system with emphasis on lower index bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.arange(len(bins))\\n scores = bins / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03854,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a quadratic priority of the bin, where the priority is set to the square of the index of the bin.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) ** 2\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03864,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n scores = np.where(utilization_ratio > 0.9, utilization_ratio, 0.1)\\n return scores\",\n \"objective\": 0.03874,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will use the concept of harmonic priority, where the score function will be calculated based on the harmonic series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / (np.arange(len(bins)) + 1)\\n scores = 1 / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03884,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and a linear priority of the bin, where the priority is set to the index of the bin.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins))\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03904,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity and the priority of the bin based on its index, resulting in a more linear and index-based scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = 1 / np.arange(1, len(bins) + 1)\\n scores = bins / (bins - item) * priority\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will be calculated based on the remaining capacity of the bin, with a penalty applied for bins with a capacity below a certain threshold, encouraging the utilization of higher capacity bins, using a novel penalty calculation method and a modified form of the score calculation.\\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins))) # New penalty calculation method\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n penalty[bins < threshold] *= 2 # Apply penalty for bins below the threshold\\n scores = bins / (bins - item + 0.1) - penalty # Modified score calculation\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = np.exp(np.arange(len(bins)))\\n threshold = 0.2 * bins.max()\\n penalty[bins < threshold] *= 2\\n scores = bins / (bins - item + 0.1) - penalty\\n scores -= np.where(bins == bins.max(), np.inf, 0)\\n return scores\",\n \"objective\": 0.03924,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will be calculated based on the logarithm of the remaining capacity of the bin, with a penalty applied for bins with close to full capacity, while also considering a specific threshold for the item size and an additional constraint on the index of the bins, ensuring a unique and efficient scoring system.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.log(bins) - (bins - item < threshold) * 2 - bin_indexes ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03934,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_20.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff) + 0.5, (1 - diff / bins) * np.sqrt(diff))\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00684,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will incorporate a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff + 3) + 0.8, (1 - diff / bins) * np.sqrt(diff + 0.5) + 0.3)\\n scores = (bins) / (np.exp(diff) + 0.7) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00714,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm assigns scores to each bin using a weighted combination of the utilization ratio, a modified exponential decay factor, and a static adjustment to minimize the number of used bins for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modifier = utilization_ratio * np.sqrt(bins - item + 1)\\n static_adjustment = np.where(bins - item > (item * 2), modifier + 0.7, modifier + 0.5)\\n scores = (item * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-(bins - item)**2) + static_adjustment\\n return scores\",\n \"objective\": 0.00724,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is based on a combination of item size, remaining bin capacity, a novel weighted dynamic adjustment, and a modified decaying factor to assign scores to each bin, with the aim to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n weight = np.sqrt((bins - item) + 1)\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * weight + 0.8, (1 - diff / bins) * weight + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of exponential and linear decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n linear_decay = (bins * 1.2) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = linear_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm incorporates a combination of utilization ratio, a modified exponential decay factor, and a dynamic adjustment based on the ratio of item size to bin capacity to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), utilization_ratio * np.sqrt(bins - item + 2) + 0.9, utilization_ratio * np.sqrt(bins - item + 1) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins / 2) / (np.exp(diff / 2) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes the utilization ratio and an adaptive dynamic adjustment based on the difference between the item size and bin capacities, along with an exponentially decaying factor, to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin using a combination of the utilization ratio, a dynamic adjustment, and a non-linear decay factor to optimize item distribution and minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (item * 1.5) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm utilizes a combination of geometric and arithmetic decay with a novel dynamic adjustment to assign scores to each bin based on the item size and the remaining capacity, aiming to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n geometric_decay = (bins * 1.5) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff))\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = geometric_decay + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00815,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm focuses on incorporating a weighted average of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with varying parameter settings to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.5)\\n scores = (bins) / (np.exp(diff) + 0.5) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm focuses on the utilization ratio and dynamic adjustment to assign scores to each bin for item assignment, incorporating an exponentially decaying factor with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 4) + 0.8, (1 - diff / bins) * np.sqrt(diff + 2) + 0.6)\\n scores = (bins * 1.4) / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00835,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will use a linear combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor, with different parameter settings to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 3), (1 - diff / bins) * np.sqrt(diff + 4) + 0.6, (1 - diff / bins) * np.sqrt(diff + 0.7) + 0.2)\\n scores = (bins) / (np.exp(diff) + 0.8) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm calculates scores for each bin based on a novel combination of the utilization ratio, adaptive dynamic adjustment, and a customized decaying factor, introducing a new element to minimize the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n dynamic_adjustment = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.6, (1 - diff / bins) * np.sqrt(diff + 1) + 0.4)\\n scores = (bins * 1.8) / (np.exp(diff) + 0.6) * np.exp(-np.abs(diff)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 3) + 0.7, (1 - diff / bins) * np.sqrt(diff + 2) + 0.5)\\n scores = (bins * 1.3) / (np.exp(diff) + 0.3) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.7, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = bins / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor by adjusting the original algorithm to prioritize bins with higher remaining capacities and taking into account the item size to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 1) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.7)\\n scores = bins / (np.exp(diff) + 0.4) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00885,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and a unique scoring mechanism.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_threshold = 0.3 * bins.max()\\n penalty = (bins - item) < penalty_threshold\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with an additional penalty for bins close to full capacity, ensuring self-consistency and a unique scoring mechanism.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalty for bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component, and minimizing the number of used bins by prioritizing bins with higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins - item) < 0.2 * bins.max() # Penalty for bins close to full capacity\\n scores = 1 / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, incorporating a penalty for the bins with capacities close to full, and also considering a unique adjustment factor for each bin based on its position, resulting in a novel and efficient scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will be based on the concept of geometric priority, where the score function will be calculated by taking the geometric mean of the priority of the bin with the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and minimizing the number of used bins. \\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, incorporating a penalty for the deviation from the average capacity of all bins, and also considering the absolute difference between the bin capacity and the item size.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity)\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.03109,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 1)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03179,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will use the concept of geometric series priority, where the score function will be calculated based on the geometric series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_threshold = 0.2 * bins.max()\\n penalty = (bins - item) < penalty_threshold\\n scores = 2 ** np.arange(len(bins)) / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.033,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 1.7\\n scores = scores / np.log10(bin_indexes + 1)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.0333,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the item size to the remaining capacity of the bin, while also implementing a non-linear adjustment for the scores and penalizing the bins with capacities close to full, ensuring self-consistency and minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.25 * bins.max() \\n scores = 1 / (bins - item) - (bins - item < penalty) * 2.5\\n scores = scores / np.log2(np.arange(len(bins)) + 2)\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03491,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm will use the concept of exponential priority, where the score function will be calculated based on the exponential series of the priority of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty_threshold = 0.2 * bins.max()\\n penalty = (bins - item) < penalty_threshold\\n scores = np.exp(np.arange(len(bins))) / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03501,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the relative position of the bin in the array, with an additional penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.3 * max_bins\\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.log(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03602,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the square root of the remaining capacity of the bin, penalizing bins with remaining capacity close to full, and further adjusting the scores based on the index of the bins in a non-linear manner, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.sqrt(bins) - (bins - item < threshold) * 2 - np.sqrt(bin_indexes) ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03612,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the ratio between the item size and the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item / (bins - item))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.03622,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, with an additional penalty for bins close to full capacity, while also considering the position of the bins and implementing a non-linear adjustment for the scores, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.15 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 1.5\\n scores = scores / np.log10(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03703,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the remaining capacity of the bin, incorporating a penalty for bins with remaining capacity close to full, and further adjusting the scores based on the index of the bins in a non-linear manner, resulting in a unique and efficient scoring system.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold = 0.2 * bins.max() # Threshold for penalty\\n bin_indexes = np.arange(len(bins))\\n scores = np.log(bins) - (bins - item < threshold) * 2 - np.sqrt(bin_indexes) ** 2\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03713,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Utilizing a modified priority calculation and penalty method based on remaining bin capacity to ensure self-consistency and avoid randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(1, len(bins) + 1) ** 2 # Modified priority calculation\\n threshold = 0.3 * bins.max()\\n penalty = (bins - item) < threshold # Apply penalty for bins close to full capacity\\n scores = bins / (bins - item) * priority - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03743,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00730,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item**2 + 1) / (bins - item + 1) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * max(bins)\\n scores = np.log(item**2) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then adjust the scores non-linearly with an additional penalty for bins close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.2 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.25 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.sqrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, squared, with an additional non-linear adjustment for the scores, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item**2) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.2 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a mixture of the square root and the natural logarithm of the item size to the remaining capacity of the bin, with an additional penalty for bins close to full capacity, ensuring a unique and consistent scoring system without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n threshold_penalty = 0.2 * max_bins\\n penalty = (bins - item) < threshold_penalty\\n scores = (np.sqrt(item) + np.log(item)) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component, and minimizing the number of used bins by prioritizing bins with higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins - item) < 0.2 * bins.max() # Penalty for bins close to full capacity\\n scores = 1 / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description:\\nThe new algorithm will calculate the score function by taking the reciprocal of the priority of the bin with remaining capacity, with a penalty for bins close to full capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n reciprocal_priority = 1 / priority\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = reciprocal_priority / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, penalizing the bins with larger capacities, and also considering the absolute difference between the bin capacity and the item size, with a smaller penalty for the deviation from the average capacity of all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity) * 0.5 # Smaller penalty for deviation from average capacity\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position, resulting in an efficient and modified scoring system to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 5)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nNew algorithm: The score function will calculate the scores for each bin based on an exponential function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position of the bin, ensuring self-consistency and a different form from the given algorithms.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.2 * np.max(bins) \\n bin_indexes = np.arange(len(bins))\\n scores = np.exp(1 / (bins - item)) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == np.max(bins))[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03008,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin using a linear function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position, resulting in an efficient and modified scoring system to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = np.max(bins)\\n penalty = 0.2 * max_bins\\n bin_indexes = np.arange(len(bins))\\n adjusted_item = bins - item\\n \\n scores = (1 / adjusted_item) - (adjusted_item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 3)\\n \\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n \\n return scores\",\n \"objective\": 0.03049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, incorporating a penalty for the bins with capacities close to full, and also considering a unique adjustment factor for each bin based on its position, resulting in a novel and efficient scoring system.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 2)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.03069,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will be based on the concept of geometric priority, where the score function will be calculated by taking the geometric mean of the priority of the bin with the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and minimizing the number of used bins. \\n\\nimport numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n geometric_mean = np.prod(priority) ** (1 / len(priority))\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = geometric_mean / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.03079,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cube root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.cbrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item**2 + 1) / (bins - item + 1) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, with an adjustment for the utilization ratio and a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = (item**(1/3)) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * max(bins)\\n scores = np.log(item**2) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then adjust the scores non-linearly with an additional penalty for bins close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.2 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01982,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.25 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.sqrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02022,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.sqrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02224,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.25 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - (penalty * 0.5)\\n return scores\",\n \"objective\": 0.02354,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, squared, with an additional non-linear adjustment for the scores, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item**2) / (bins - item)\\n penalty = (bins - item) < 0.3 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.02435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.2 * np.max(bins)\\n scores = np.log(item) / (bins - item) - (bins - item < penalty) * 1.0\\n return scores\",\n \"objective\": 0.02475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on a mixture of the square root and the natural logarithm of the item size to the remaining capacity of the bin, with an additional penalty for bins close to full capacity, ensuring a unique and consistent scoring system without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n threshold_penalty = 0.2 * max_bins\\n penalty = (bins - item) < threshold_penalty\\n scores = (np.sqrt(item) + np.log(item)) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.02847,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the exponential of the ratio between the item size and the remaining capacity of the bin, penalizing bins with remaining capacity below a certain threshold and ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.exp(item / bins) - penalty\\n return scores\",\n \"objective\": 0.02878,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the inverse of the remaining capacity, with a penalty for bins close to full capacity, ensuring self-consistency and avoiding the random component, and minimizing the number of used bins by prioritizing bins with higher remaining capacity.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = (bins - item) < 0.2 * bins.max() # Penalty for bins close to full capacity\\n scores = 1 / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02918,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description:\\nThe new algorithm will calculate the score function by taking the reciprocal of the priority of the bin with remaining capacity, with a penalty for bins close to full capacity, to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n priority = np.arange(len(bins)) + 1\\n reciprocal_priority = 1 / priority\\n penalty = (bins - item) < 0.2 * bins.max()\\n scores = reciprocal_priority / (bins - item) - penalty\\n scores[bins == bins.max()] = -np.inf\\n return scores\",\n \"objective\": 0.02938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the remaining capacity of the bin, penalizing the bins with larger capacities, and also considering the absolute difference between the bin capacity and the item size, with a smaller penalty for the deviation from the average capacity of all bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n avg_capacity = np.mean(bins)\\n penalty = np.abs(bins - avg_capacity) * 0.5 # Smaller penalty for deviation from average capacity\\n scores = bins / (bins - item) - penalty\\n max_capacity_bins = np.where(bins == bins.max())[0]\\n scores[max_capacity_bins] = -np.inf\\n return scores\",\n \"objective\": 0.02958,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin using a non-linear function of the remaining capacity of the bin, with a penalty for capacities close to full and a unique adjustment factor based on the position, resulting in an efficient and modified scoring system to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_bins = bins.max()\\n penalty = 0.2 * max_bins \\n bin_indexes = np.arange(len(bins))\\n scores = 1 / (bins - item) - (bins - item < penalty) * 2\\n scores = scores / np.sqrt(bin_indexes + 5)\\n max_capacity_bins = np.where(bins == max_bins)[0]\\n for idx in max_capacity_bins:\\n scores[idx] = -np.inf\\n return scores\",\n \"objective\": 0.02988,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n adjust = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the exponential of the remaining capacity of the bins and logarithm of the item size to minimize the number of used bins. It uses a modified scoring function based on the exponential of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.1)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithmic of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n adjusted_bins = bins - item\\n scores = np.log(item) / adjusted_bins - (adjusted_bins < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm improves item distribution by adjusting the scoring function based on remaining capacity, utilization ratio, and item size, using different parameter settings for the dynamic adjustment and exponentially decaying factor to assign scores to each bin, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will assign scores to the bins based on the ratio of the logarithm of the item size to the remaining capacity of the bin, incorporating a dynamic adjustment for optimization and a factor that penalizes bins close to full capacity, ensuring consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n adjusted_bins = bins - item\\n utilization_ratio = np.log(item) / (adjusted_bins + 1)\\n dynamic_adjustment = np.where(adjusted_bins > (item * 2), utilization_ratio * 1.2, utilization_ratio * 0.8)\\n scores = utilization_ratio + dynamic_adjustment - (adjusted_bins < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cube root of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.cbrt(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01167,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item**2 + 1) / (bins - item + 1) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n threshold_penalty = 0.3 * max(bins)\\n penalty = (bins - item) < threshold_penalty\\n scores = np.log(item) / (bins - item) - penalty\\n return scores\",\n \"objective\": 0.01288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the square root of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n adjusted_bins = bins - item\\n scores = np.sqrt(item) / adjusted_bins - (adjusted_bins < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01449,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm dynamically adjusts the scoring function to minimize the number of used bins and optimize item distribution by considering the item size and remaining capacity of the bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01479,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm dynamically adjusts the scoring function to minimize the number of used bins and optimize item distribution by considering the item size and remaining capacity of the bins, using a modified formula that takes into account both the remaining capacity and the item size.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n modified_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) + modified_adjustment\\n return scores\",\n \"objective\": 0.01499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the utilization ratio and a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, with an adjustment for the utilization ratio and a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = (item**(1/3)) / (bins - item)\\n penalty = (bins - item) < 0.25 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01539,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with a penalty for bins close to full capacity, ensuring self-consistency without introducing randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.25 * np.max(bins) # Penalty for bins close to full capacity\\n scores = np.log(item) / (bins - item) - (bins - item < penalty) * 1.2\\n return scores\",\n \"objective\": 0.01549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, and then adjust the scores to penalize bins close to full capacity, ensuring self-consistency and avoiding randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.log(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.0157,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the squared item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * max(bins)\\n scores = np.log(item**2) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.0159,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The score function will calculate the scores for each bin based on the cubic root of the item size to the remaining capacity of the bin, and then penalize the bins which are close to full capacity, ensuring self-consistency and avoiding randomness.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = np.cbrt(item) / (bins - item)\\n penalty = (bins - item) < 0.4 * bins.max() # Penalize bins close to full capacity\\n scores = utilization_ratio - penalty\\n return scores\",\n \"objective\": 0.01751,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm dynamically adjusts the scoring function based on the utilization ratio and a decaying factor to assign scores to each bin for item assignment, optimizing item distribution and minimizing the number of used bins.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n decaying_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * decaying_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n adjust = np.where((bins - item) > (item * 2), (1 - (bins - item) / bins) * np.sqrt(bins - item + 2) + 0.8, (1 - (bins - item) / bins) * np.sqrt(bins - item + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and a modified decay factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the item size, remaining capacity of the bins, and a combination of dynamic adjustment and an exponentially decaying factor to assign scores to each bin to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.4)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes non-linear dynamic adjustment and the integration of item size and remaining capacity to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n non_linear_dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.2, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + non_linear_dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a combination of the square root of the utilization ratio, the natural logarithm of the item size, and an adjusted dynamic factor to calculate the scores for each bin assignment to minimize the number of used bins and optimize item distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.3)\\n scores = (np.log(item) + bins * 1.5) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the utilization ratio, dynamic adjustment, and an exponentially decaying factor while also considering the logarithm of the item size and exponential of the remaining capacity of the bins, ultimately facilitating the selection of the bin with the maximum score for item assignment by using a modified scoring function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the utilization ratio, dynamic adjustment, and an exponentially decaying factor while also considering the logarithm of the item size and exponential of the remaining capacity of the bins, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.15) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm aims to optimize item distribution by leveraging the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the exponential of the remaining capacity of the bins and logarithm of the item size to minimize the number of used bins. It uses a modified scoring function based on the exponential of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.1)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\\n\\n# Simplified version\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = utilization_ratio * np.sqrt(bins - item + 1) + 0.6\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The score function will calculate the scores for each bin based on the logarithm of the item size to the remaining capacity of the bin, with an adjustment for the bins close to full capacity, ensuring self-consistency without introducing randomness.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n penalty = 0.3 * np.max(bins)\\n scores = np.log(item) / (bins - item) - (bins - item < penalty) * 1.5\\n return scores\",\n \"objective\": 0.01006,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to minimize the number of used bins and optimize item distribution by adjusting the scoring function based on the item size and the remaining capacity of the bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.4)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01016,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm aims to optimize item distribution by considering the utilization ratio, dynamic adjustment, and a modified scoring function that takes into account the remaining capacity of the bins and the item size. The scores are calculated by using an adjusted formula based on the remaining capacity and item size while incorporating the utilization ratio and a dynamic adjustment factor.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.1, (utilization_ratio * np.sqrt(bins - item)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01026,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm utilizes a modified approach of the scoring function by incorporating the item size, remaining bin capacity, utilization ratio, and dynamic adjustment, ultimately aiming to minimize the number of used bins while optimizing item distribution.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.25)\\n scores = (bins * 1.3) / (np.log(bins + 1) * (bins - item + 2)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01036,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm improves item distribution by adjusting the scoring function based on remaining capacity, utilization ratio, and item size, using different parameter settings for the dynamic adjustment and exponentially decaying factor to assign scores to each bin, ultimately minimizing the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 2)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.01077,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating item size, remaining capacity of the bins, and a modified scoring function based on the utilization ratio and dynamic adjustment to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n adjust = np.where((bins - item) > (item * 2), (1 - (bins - item) / bins) * np.sqrt(bins - item + 2) + 0.8, (1 - (bins - item) / bins) * np.sqrt(bins - item + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and a modified decay factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the item size, remaining capacity of the bins, and a combination of dynamic adjustment and an exponentially decaying factor to assign scores to each bin to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.4)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating a novel combination of the utilization ratio, dynamic adjustment, and a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the utilization ratio, dynamic adjustment, and an exponentially decaying factor while also considering the logarithm of the item size and exponential of the remaining capacity of the bins, ultimately facilitating the selection of the bin with the maximum score for item assignment by using a modified scoring function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.05) / (np.exp(bins - item) + 0.15) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, item size, and utilization ratio to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2.5), (1 - remaining_capacity / bins) * np.sqrt(bins - item + 1) + 0.6, (1 - remaining_capacity / bins) * np.sqrt(bins - item + 1) + 0.4)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm aims to optimize item distribution by leveraging the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\\nCode:\\nimport numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.15, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.2)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm uses a combination of utilization ratio, sigmoid function, and a modified logarithmic factor based on item size and remaining capacity of the bins to assign scores to each bin for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n sigmoid_function = 1 / (1 + np.exp(bins - item))\\n scores = (bins * 1.2) / (np.log(item + 1) + 0.5) * sigmoid_function + (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7\\n return scores\",\n \"objective\": 0.00976,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to optimize item distribution by incorporating the square root of the remaining capacity of the bins and the item size to minimize the number of used bins. It uses a modified scoring function based on the square root of the utilization ratio and a dynamic adjustment factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n dynamic_adjustment = utilization_ratio * np.sqrt(bins - item) + 0.5\\n scores = (2 * bins) / (np.sqrt(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00986,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob1_OnlineBinPacking/run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm utilizes a dynamic adjustment of the scoring function based on the item size and the remaining capacity of the bins to minimize the number of used bins and optimize item distribution.\",\n \"code\": \"import numpy as np\\n def score(item, bins):\\n remaining_capacity = bins - item\\n utilization_ratio = 1 - remaining_capacity / bins\\n simulated_annealing_factor = np.exp(-np.abs(bins - item))\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins *1.1) / (np.exp(bins - item) + 0.1) * simulated_annealing_factor + dynamic_adjustment\\n return scores\",\n \"objective\": 0.0073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00734,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm assigns scores to each bin based on a combination of the utilization ratio, a novel dynamic adjustment, and a non-linearly decaying factor, incorporating a different parameter setting to facilitate the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00745,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins. It uses a scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n diff = bins - item\\n adjust = np.where(diff > (item * 2), (1 - diff / bins) * np.sqrt(diff + 2) + 0.8, (1 - diff / bins) * np.sqrt(diff + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(diff) + 0.2) * np.exp(-np.abs(diff)) + adjust\\n return scores\",\n \"objective\": 0.00755,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm calculates the scores for each bin based on the utilization ratio, dynamic adjustment, and a modified exponential decay factor to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decay factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where(bins - item > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 2) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00765,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor with different parameter settings to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.8, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.2) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00785,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm utilizes a different scoring function based on the utilization ratio, dynamic adjustment, and a linearly decaying factor with distinct parameter settings to assign scores to each bin, thus facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 2)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00795,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, item size, and utilization ratio to minimize the number of used bins. It uses a modified scoring function based on the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n remaining_capacity = bins - item\\n dynamic_adjustment = np.where(remaining_capacity > (item * 2), (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.8, (1 - remaining_capacity / (bins + 1)) * np.sqrt(bins - item + 1) + 0.6)\\n scores = (bins * 1.2) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00805,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by incorporating a novel combination of the utilization ratio, dynamic adjustment, and a non-linear decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.9, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7)\\n scores = (bins * 1.3) / (np.exp(bins - item) + 0.4) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00825,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to assign scores to each bin based on a combination of the weighing of the utilization ratio, dynamic adjustment, and an exponentially decaying factor with a unique weighting factor, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.4) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm aims to optimize item distribution by utilizing a stepwise scoring function based on the utilization ratio, dynamic adjustment, and a non-linearly decaying factor to assign scores to each bin, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1.5)) + 0.75, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.5) / (np.exp(bins - item) + 0.5) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00865,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor, and it is implemented in the function named score in Python.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp((bins - item)**0.8) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00895,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (bins) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00906,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm uses a scoring function with parameters such as utilization ratio, dynamic adjustment, and a linearly decaying factor, calculated using different parameter settings, to assign scores to each bin based on their remaining capacity, facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n adjust = np.where((bins - item) > (item * 3), (utilization_ratio * np.sqrt(bins - item + 3)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5)\\n scores = (bins * 1.8) / (np.exp(bins - item) + 0.7) * np.exp(-np.abs(bins - item)) + adjust\\n return scores\",\n \"objective\": 0.00916,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Common backbone idea in the provided algorithms: The algorithms aim to optimize item distribution by incorporating the remaining capacity of the bins and item size to minimize the number of used bins, using a scoring function based on utilization ratio, dynamic adjustment, and an exponentially decaying factor.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (2 * bins) / (np.log(bins + 1) * (bins - item + 1)) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by combining the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin and facilitate the selection of the bin with the maximum score for item assignment. \\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6\\n scores = (item) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00936,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm will aim to optimize item distribution by incorporating the remaining capacity of the bins, item size, and the distance between the item size and the bin capacity to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 3), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.5, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.3)\\n scores = (bins) / (np.exp(bins - item) + 0.3) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00946,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to optimize item distribution by incorporating the remaining capacity of the bins, and item size to minimize the number of used bins. The scoring function will be based on a combination of the utilization ratio, dynamic adjustment, and an exponentially decaying factor to assign scores to each bin, ultimately facilitating the selection of the bin with the maximum score for item assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = np.where((bins - item) > (item * 2), (utilization_ratio * np.sqrt(bins - item + 1)) + 0.7, (utilization_ratio * np.sqrt(bins - item + 1)) + 0.6)\\n scores = (bins * 1.1) / (np.exp(bins - item) + 0.1) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00956,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The new algorithm is to calculate the scores for each bin based on the rest capacity of the bins and the size of the current item, aiming to minimize the number of used bins by incorporating a combination of the utilization ratio, dynamic adjustment, and a modified decaying factor with different parameter settings to the original algorithm. \\n\\nPython code for the new algorithm:\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n utilization_ratio = 1 - (bins - item) / bins\\n dynamic_adjustment = (utilization_ratio * np.sqrt(bins - item + 1)) + 0.8\\n scores = (bins) / (np.exp((bins - item)**0.7) + 0.05) * np.exp(-np.abs(bins - item)) + dynamic_adjustment\\n return scores\",\n \"objective\": 0.00966,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] *= (1 + edge_count[i][j] / edge_n_used[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.65616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves identifying edges that are heavily used in the local optimal tour and updating their distance in the edge distance matrix to prioritize less frequently used edges, thus promoting exploration of different routes.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.argmax(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n updated_edge_distance[start][end] *= (1 + edge_n_used[start][end]/max_used_edge)\\n return updated_edge_distance\",\n \"objective\": 2.62194,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will use the local optimal tour and the edge_n_used matrix to update the edge distance matrix by increasing the distances of edges used frequently in the local optimal tour, in order to explore alternative routes and avoid getting trapped in the local optimum.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n max_edge_usage = np.max(edge_n_used)\\n for i in range(len(local_opt_tour)):\\n city1 = local_opt_tour[i]\\n city2 = local_opt_tour[(i + 1) % len(local_opt_tour)]\\n if edge_n_used[city1, city2] == max_edge_usage:\\n updated_edge_distance[city1, city2] *= 1.5\\n \\n return updated_edge_distance\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n max_edge_usage = np.max(edge_n_used)\\n for i in range(len(local_opt_tour)):\\n city1 = local_opt_tour[i]\\n city2 = local_opt_tour[(i + 1) % len(local_opt_tour)]\\n if edge_n_used[city1, city2] == max_edge_usage:\\n updated_edge_distance[city1, city2] *= 1.5\\n \\n return updated_edge_distance\",\n \"objective\": 3.06007,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will identify the edges that are heavily used in the local optimal tour and iteratively increase their distances in the edge distance matrix to encourage exploration of different routes.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.argmax(edge_n_used)\\n local_opt_tour = np.append(local_opt_tour, local_opt_tour[0])\\n \\n for i in range(len(local_opt_tour)-1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n updated_edge_distance[start_node, end_node] *= 1.1\\n updated_edge_distance[end_node, start_node] *= 1.1\\n \\n return updated_edge_distance\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.argmax(edge_n_used)\\n local_opt_tour = np.append(local_opt_tour, local_opt_tour[0])\\n \\n for i in range(len(local_opt_tour)-1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n updated_edge_distance[start_node, end_node] *= 1.1\\n updated_edge_distance[end_node, start_node] *= 1.1\\n \\n return updated_edge_distance\",\n \"objective\": 3.25973,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Create a strategy to randomly perturb the edge distances along the local optimal route to escape from the local optimum and move towards a global optimum, by increasing the distances of the edges used in the local optimal tour.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_edges = edge_distance.shape[0]\\n \\n # Increase the distance of edges used in the local optimal tour\\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n updated_edge_distance[start_node][end_node] *= 1.1\\n \\n return updated_edge_distance\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_edges = edge_distance.shape[0]\\n \\n # Increase the distance of edges used in the local optimal tour\\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n updated_edge_distance[start_node][end_node] *= 1.1\\n \\n return updated_edge_distance\",\n \"objective\": 3.2823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: \\nUpdate the edge distance matrix based on the local optimal route to avoid being trapped in local optimum by increasing the distance of edges that are frequently used in the local optimal route and decreasing the distance of edges that are infrequently used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n min_edge_usage = np.min(edge_n_used)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n \\n edge_distance_diff = (edge_n_used[start_node, end_node] - min_edge_usage) / (max_edge_usage - min_edge_usage)\\n \\n updated_edge_distance[start_node, end_node] *= (1 + 0.5 * edge_distance_diff)\\n updated_edge_distance[end_node, start_node] = updated_edge_distance[start_node, end_node]\\n \\n return updated_edge_distance\",\n \"objective\": 3.37258,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will update the edge distance matrix by identifying the edges involved in the local optimal tour and increasing their distances to discourage their usage, while decreasing the distances of non-participating edges to encourage their selection in the next iteration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n updated_edge_distance[start_node, end_node] *= 1.1 # Increase distance of edges in local optimal tour\\n updated_edge_distance[end_node, start_node] *= 1.1 # Increase distance of edges in local optimal tour\\n for i in range(len(edge_distance)):\\n for j in range(len(edge_distance[0])):\\n if edge_n_used[i, j] == 0:\\n updated_edge_distance[i, j] *= 0.9 # Decrease distance of non-participating edges\\n return updated_edge_distance\",\n \"objective\": 3.45938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The new algorithm involves identifying the edges in the local optimal tour that are frequently used and updating the edge distance matrix to increase the distance of those edges, thus encouraging the algorithm to explore different paths.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.argmax(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n if local_opt_tour[i] == max_used_edge or local_opt_tour[i+1] == max_used_edge:\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] *= 1.1\\n updated_edge_distance[local_opt_tour[i+1], local_opt_tour[i]] *= 1.1\\n return updated_edge_distance\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.argmax(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n if local_opt_tour[i] == max_used_edge or local_opt_tour[i+1] == max_used_edge:\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] *= 1.1\\n updated_edge_distance[local_opt_tour[i+1], local_opt_tour[i]] *= 1.1\\n return updated_edge_distance\",\n \"objective\": 3.48552,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distance matrix by identifying the edges used in the local optimal tour and increasing their distances in the matrix, in order to encourage exploration of different routes.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n edge_idx = (start_node, end_node) if start_node < end_node else (end_node, start_node)\\n edge_idx = np.where((edge_n_used[:, 0] == edge_idx[0]) & (edge_n_used[:, 1] == edge_idx[1]))[0]\\n updated_edge_distance[edge_idx] *= 1.5 # Increase the distance of the used edges\\n return updated_edge_distance\",\n \"objective\": 3.49348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nCreate a strategy to update the edge distance matrix by identifying the edges in the local optimal tour and increasing their distances, while decreasing the distances of non-used edges to create new opportunities for finding a better tour.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n node1 = local_opt_tour[i]\\n node2 = local_opt_tour[i+1]\\n updated_edge_distance[node1][node2] *= 1.1\\n updated_edge_distance[node2][node1] *= 1.1\\n\\n for i in range(len(edge_n_used)):\\n if edge_n_used[i] == 0:\\n node1 = i // len(edge_distance)\\n node2 = i % len(edge_distance)\\n updated_edge_distance[node1][node2] *= 0.9\\n updated_edge_distance[node2][node1] *= 0.9\\n\\n return updated_edge_distance\",\n \"objective\": 10000000000.0,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_count[edge_n_used == 0] = 1 # simplified to avoid overfitting\\n\\n updated_edge_distance *= (1 + edge_count / edge_n_used)\\n\\n return updated_edge_distance\",\n \"objective\": 0.20408,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] *= (1 + edge_count[i][j] / edge_n_used[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.65616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] *= (1 + edge_count[i][j] / (edge_n_used[i][j] + 1))\\n return updated_edge_distance\",\n \"objective\": 1.12469,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves identifying edges that are heavily used in the local optimal tour and updating their distance in the edge distance matrix to prioritize less frequently used edges, thus promoting exploration of different routes, while scaling the update factor by the inverse square root of the edge's usage frequency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.max(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n updated_edge_distance[start][end] *= (1 + 1/np.sqrt(edge_n_used[start][end]+1))\\n return updated_edge_distance\",\n \"objective\": 1.34281,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves identifying edges that are heavily used in the local optimal tour and updating their distance in the edge distance matrix to prioritize less frequently used edges, thus promoting exploration of different routes, while scaling the update factor by the inverse of the edge's usage frequency.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.max(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n updated_edge_distance[start][end] *= (1 + 1/(edge_n_used[start][end]+1))\\n return updated_edge_distance\",\n \"objective\": 1.84289,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Modify the edge distances randomly along the local optimal route to escape from the local optimum and move towards a global optimum, by perturbing the distances of the edges used in the local optimal tour.\\n\\nCode:\\nimport numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n perturbation_factor = np.random.uniform(0.9, 1.1) # Randomly perturb the edge distance\\n updated_edge_distance[start_node][end_node] *= perturbation_factor\\n \\n return updated_edge_distance\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n perturbation_factor = np.random.uniform(0.9, 1.1) # Randomly perturb the edge distance\\n updated_edge_distance[start_node][end_node] *= perturbation_factor\\n\\n return updated_edge_distance\",\n \"objective\": 2.61658,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm involves identifying edges that are heavily used in the local optimal tour and updating their distance in the edge distance matrix to prioritize less frequently used edges, thus promoting exploration of different routes.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_used_edge = np.argmax(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n updated_edge_distance[start][end] *= (1 + edge_n_used[start][end]/max_used_edge)\\n return updated_edge_distance\",\n \"objective\": 2.62194,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Identify the least frequently used edges in the local optimal tour and update their distances in the edge distance matrix to encourage exploration of different routes, while also randomizing the distances of non-participating edges to promote diversification in the search for a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n min_used_edge = np.argmin(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n if edge_n_used[start][end] < np.mean(edge_n_used): # Update distances of least frequently used edges\\n updated_edge_distance[start][end] *= (1 - edge_n_used[start][end]/min_used_edge)\\n updated_edge_distance[end][start] *= (1 - edge_n_used[end][start]/min_used_edge)\\n else: # Randomly perturb the distances of non-participating edges\\n perturbation_factor = np.random.uniform(0.9, 1.1)\\n updated_edge_distance[start][end] *= perturbation_factor\\n updated_edge_distance[end][start] *= perturbation_factor\\n return updated_edge_distance\",\n \"objective\": 2.67133,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Modify the edge distances randomly along the local optimal route to escape from the local optimum and move towards a global optimum, by perturbing the distances of the edges used in the local optimal tour.\\n\\nCode:\\nimport numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n perturbation_factor = np.random.uniform(0.9, 1.1) # Randomly perturb the edge distance\\n updated_edge_distance[start_node][end_node] *= perturbation_factor\\n \\n return updated_edge_distance\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n perturbation_factor = np.random.uniform(0.9, 1.1) # Randomly perturb the edge distance\\n updated_edge_distance[start_node][end_node] *= perturbation_factor\\n \\n return updated_edge_distance\",\n \"objective\": 2.72499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 0.25\\n edge_count[end][start] += 0.25\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] *= (1 + (edge_count[i][j] / (edge_n_used[i][j] + 1)) * 0.5)\\n\\n return updated_edge_distance\",\n \"objective\": 2.73776,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.05 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01541,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings, using a different decay factor, noise factor, and edge_n_used_max compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.1 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01633,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix by incorporating a dynamic scaling factor that takes into account the frequency of edge usage, the reciprocal of the edge count, and the mean edge distance to promote exploration and improve the search for a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n scaling_factor = (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1)))) / mean_edge_distance\\n updated_edge_distance[i][j] += scaling_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.05\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.0173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nUpdate the edge distances in the edge distance matrix by applying a dynamic weight factor that adjusts based on edge count, distance, and usage, with the intention of balancing exploration and exploitation for improved search performance while also incorporating a new heuristic for edge distance update.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n weight_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] + np.log(1 + edge_count[i][j])\\n updated_edge_distance[i][j] += weight_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01837,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by adjusting the distances based on the edge count, distance, and usage, incorporating a Gaussian noise factor and a custom heuristic function to steer the search towards a more optimal solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_distance = np.mean(edge_distance)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.normal(loc=0.0, scale=0.1) / edge_count[i][j] + edge_distance[i][j] / mean_distance - 0.3 / edge_n_used_max * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01841,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Modified cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function for better convergence\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.05 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01541,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings, using a different decay factor, noise factor, and edge_n_used_max compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.1 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01633,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix by incorporating a dynamic scaling factor that takes into account the frequency of edge usage, the reciprocal of the edge count, and the mean edge distance to promote exploration and improve the search for a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n scaling_factor = (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1)))) / mean_edge_distance\\n updated_edge_distance[i][j] += scaling_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.05\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.0173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nUpdate the edge distances in the edge distance matrix by applying a dynamic weight factor that adjusts based on edge count, distance, and usage, with the intention of balancing exploration and exploitation for improved search performance while also incorporating a new heuristic for edge distance update.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n weight_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] + np.log(1 + edge_count[i][j])\\n updated_edge_distance[i][j] += weight_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01837,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Modified cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function for better convergence\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.05 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01541,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings, using a different decay factor, noise factor, and edge_n_used_max compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.1 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01633,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix by incorporating a dynamic scaling factor that takes into account the frequency of edge usage, the reciprocal of the edge count, and the mean edge distance to promote exploration and improve the search for a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n scaling_factor = (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1)))) / mean_edge_distance\\n updated_edge_distance[i][j] += scaling_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings, using a different decay factor, noise factor, and edge_n_used_max compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.2 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.9, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01702,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized genetic function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n def genetic_function(x):\\n return (np.tanh(x)) # Simplified custom function\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.00994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New modified cuckoo search-inspired function with different parameter settings\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01013,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Modified cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function for better convergence\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.05 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01541,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings, using a different decay factor, noise factor, and edge_n_used_max compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.1 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.0158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01633,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized genetic function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.tanh(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.00994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New modified cuckoo search-inspired function with different parameter settings\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01013,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Modified cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function for better convergence\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01497,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration, and introducing a different noise factor calculation based on the edge count, distance, and usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.9, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.5 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.05 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.1) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01541,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, with the update determined by edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings, using a different decay factor, noise factor, and edge_n_used_max compared to the original algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.1 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.0158,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized genetic function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.tanh(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.00994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New modified cuckoo search-inspired function with different parameter settings\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01013,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration, and introducing a different noise factor calculation based on the edge count, distance, and usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance)) - (0.45 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01249,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances by applying a swarm intelligence-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized swarm function to promote global exploration and improved convergence with a unique parameter setting for better convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New swarm intelligence-inspired function with unique parameter setting\\n def swarm_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**3) # Unique function with a different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (swarm_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.5 / edge_n_used_max) * edge_n_used[i][j] # Unique parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01255,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances by integrating a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, and usage, with the application of genetic operators such as selection, crossover, and mutation for improved global search and convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New genetic algorithm-inspired function\\n def genetic_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Genetic-inspired function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Modified cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function for better convergence\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01497,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized genetic function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.tanh(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.00994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New modified cuckoo search-inspired function with different parameter settings\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01013,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration, and introducing a different noise factor calculation based on the edge count, distance, and usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance)) - (0.45 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01249,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances by applying a swarm intelligence-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized swarm function to promote global exploration and improved convergence with a unique parameter setting for better convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New swarm intelligence-inspired function with unique parameter setting\\n def swarm_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**3) # Unique function with a different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (swarm_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.5 / edge_n_used_max) * edge_n_used[i][j] # Unique parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01255,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances by integrating a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, and usage, with the application of genetic operators such as selection, crossover, and mutation for improved global search and convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New genetic algorithm-inspired function\\n def genetic_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Genetic-inspired function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: In this new algorithm, we update the edge distances by emphasizing edge count and usage, and modifying the score factor to enhance exploration and convergence for better local optimum avoidance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (edge_count[i][j]) / (edge_count[i][j] + 1) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Modified score function\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized genetic function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.tanh(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.00994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New modified cuckoo search-inspired function with different parameter settings\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01013,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration, and introducing a different noise factor calculation based on the edge count, distance, and usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance)) - (0.45 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01249,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances by applying a swarm intelligence-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized swarm function to promote global exploration and improved convergence with a unique parameter setting for better convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New swarm intelligence-inspired function with unique parameter setting\\n def swarm_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**3) # Unique function with a different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (swarm_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.5 / edge_n_used_max) * edge_n_used[i][j] # Unique parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01255,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances by integrating a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, and usage, with the application of genetic operators such as selection, crossover, and mutation for improved global search and convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New genetic algorithm-inspired function\\n def genetic_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Genetic-inspired function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: In this new algorithm, we update the edge distances by emphasizing edge count and usage, and modifying the score factor to enhance exploration and convergence for better local optimum avoidance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (edge_count[i][j]) / (edge_count[i][j] + 1) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Modified score function\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized genetic function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.tanh(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.00994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New modified cuckoo search-inspired function with different parameter settings\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01013,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration, and introducing a different noise factor calculation based on the edge count, distance, and usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance)) - (0.45 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01249,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances by applying a swarm intelligence-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized swarm function to promote global exploration and improved convergence with a unique parameter setting for better convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New swarm intelligence-inspired function with unique parameter setting\\n def swarm_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**3) # Unique function with a different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (swarm_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.5 / edge_n_used_max) * edge_n_used[i][j] # Unique parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01255,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances by integrating a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, and usage, with the application of genetic operators such as selection, crossover, and mutation for improved global search and convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New genetic algorithm-inspired function\\n def genetic_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Genetic-inspired function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: In this new algorithm, we update the edge distances by emphasizing edge count and usage, and modifying the score factor to enhance exploration and convergence for better local optimum avoidance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (edge_count[i][j]) / (edge_count[i][j] + 1) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Modified score function\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.00873,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized genetic function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.tanh(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.00994,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances by applying a modified cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence with a different parameter setting in the score function for better convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New modified cuckoo search-inspired function with different parameter settings\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Modified function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01013,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering a combination of edge count, distance, and usage, while adjusting the decay factor, noise factor, and edge_n_used_max parameters for different parameter settings.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.03 # Adjusted decay factor\\n mean_distance = np.mean(edge_distance)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.5, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / mean_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] # Adjusted noise factor\\n updated_edge_distance[i][j] += noise_factor * (1.5 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01211,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration, and introducing a different noise factor calculation based on the edge count, distance, and usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.8, 1.2) / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance)) - (0.45 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01249,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances by applying a swarm intelligence-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized swarm function to promote global exploration and improved convergence with a unique parameter setting for better convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New swarm intelligence-inspired function with unique parameter setting\\n def swarm_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**3) # Unique function with a different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (swarm_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.5 / edge_n_used_max) * edge_n_used[i][j] # Unique parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01255,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances by integrating a genetic algorithm-inspired method, where the update is determined by a combination of edge count, distance, and usage, with the application of genetic operators such as selection, crossover, and mutation for improved global search and convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # New genetic algorithm-inspired function\\n def genetic_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x**2) # Genetic-inspired function with different parameter setting\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.4 / edge_n_used_max) * edge_n_used[i][j] # Updated parameter setting\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0139,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: In this new algorithm, we update the edge distances by emphasizing edge count and usage, and modifying the score factor to enhance exploration and convergence for better local optimum avoidance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (edge_count[i][j]) / (edge_count[i][j] + 1) - (0.2 / edge_n_used_max) * edge_n_used[i][j] # Modified score function\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0145,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distances based on a modified score function that includes a combination of edge count, distance, and usage factors with a genetic function for improved exploration and convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom modified genetic algorithm-inspired function\\n def modified_genetic_function(x):\\n a = np.random.uniform(0, 1)\\n b = np.random.uniform(0.5, 1.5)\\n return (x * a) / (b + x) # Modified example function, with additional parameter b\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (modified_genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01459,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_count[edge_n_used == 0] = 1 # simplified to avoid overfitting\\n\\n updated_edge_distance *= (1 + edge_count / edge_n_used)\\n\\n return updated_edge_distance\",\n \"objective\": 0.20408,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Perturb the edge distances along the local optimal route by adding a random noise factor to each edge distance, the noise factor being a random value between -0.5 and 0.5, to increase the exploration space and escape from the local optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n noise_factor = np.random.uniform(-0.5, 0.5) # Add random noise to the edge distance\\n updated_edge_distance[start_node][end_node] += noise_factor\\n \\n return updated_edge_distance\",\n \"objective\": 0.22699,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Perturb the edge distances along the local optimal route by adding a random noise factor to each edge distance, with the noise factor being a random value between -0.5 and 0.5, to escape from the local optimum and move towards a global optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n updated_edge_distance[start_node][end_node] += np.random.uniform(-0.5, 0.5)\\n \\n return updated_edge_distance\",\n \"objective\": 0.24126,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.ones_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n updated_edge_distance *= (1 + edge_count / edge_n_used)\\n\\n return updated_edge_distance\",\n \"objective\": 0.24853,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Explore the local optimal route further by randomly selecting edges to be perturbed with a random noise factor between -0.5 and 0.5, and updating the edge distances to escape from the local optimum and move towards a global optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edges_to_perturb = np.random.choice(len(local_opt_tour) - 1, size=int(0.2*(len(local_opt_tour) - 1)), replace=False) # Perturb 20% of edges\\n \\n for i in edges_to_perturb:\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n updated_edge_distance[start_node][end_node] += np.random.uniform(-0.5, 0.5)\\n \\n return updated_edge_distance\",\n \"objective\": 0.37009,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Perturb the edge distances along the local optimal route by adding a random noise factor to each edge distance, the noise factor being a random value between -0.2 and 0.2, to increase the exploration space and escape from the local optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n noise_factor = np.random.uniform(-0.2, 0.2) # Add random noise to the edge distance\\n updated_edge_distance[start_node][end_node] += noise_factor\\n \\n return updated_edge_distance\",\n \"objective\": 0.47599,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] *= (1 + edge_count[i][j] / edge_n_used[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.65616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Perturb the edge distances along the local optimal route by randomly selecting a subset of edges and adding a random noise factor to each edge distance, the noise factor being a random value between -0.5 and 0.5, to increase the exploration space and escape from the local optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Randomly select a subset of edges to perturb\\n num_edges_to_perturb = min(5, len(local_opt_tour) - 1) # Perturb at most 5 edges\\n perturbed_edges = np.random.choice(len(local_opt_tour) - 1, num_edges_to_perturb, replace=False)\\n \\n for i in perturbed_edges:\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n noise_factor = np.random.uniform(-0.5, 0.5) # Add random noise to the edge distance\\n updated_edge_distance[start_node][end_node] += noise_factor\\n \\n return updated_edge_distance\",\n \"objective\": 0.86549,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Perturb the edge distances along the local optimal route by adding a random noise factor to each edge distance, with the noise factor being a random value between -0.1 and 0.1, to escape from the local optimum and move towards a global optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n noise_factor = np.random.uniform(-0.1, 0.1) # Add random noise to the edge distance\\n updated_edge_distance[start_node][end_node] += noise_factor\\n \\n return updated_edge_distance\",\n \"objective\": 0.87495,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm strategy is to identify the edges in the local optimal tour that are infrequently used and update their distances in the edge distance matrix to encourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] *= (1 + (1 / edge_count[i][j]) * (edge_n_used[i][j] / 2 + 1))\\n return updated_edge_distance\",\n \"objective\": 0.89592,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"Update the edge distances in the edge distance matrix based on frequency of each edge used in the local optimal tour using a modified noise factor that depends on the edge count to guide the search towards a better solution\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5 / edge_count[i][j], 0.5 / edge_count[i][j])\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.09253,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplement a new algorithm that updates the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a modified noise factor that depends on the square root of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5 / np.sqrt(edge_count[i][j]), 0.5 / np.sqrt(edge_count[i][j]))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.10138,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplement a new algorithm that updates the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a modified noise factor that depends on the logarithm of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5 / np.log(edge_count[i][j] + 1), 0.5 / np.log(edge_count[i][j] + 1))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.10386,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm uses a scaling factor that inversely depends on the square root of the edge count to update the edge distances in the edge distance matrix.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n scaling_factor = np.sqrt(edge_count[i][j]) # scaling factor based on edge count\\n noise_factor = np.random.uniform(-0.5 / scaling_factor, 0.5 / scaling_factor)\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.10604,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour and the edge distance to guide the search towards a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += np.log(edge_count[i][j] + 1) / np.log(2) * (1 / edge_n_used[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.13508,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour and the edge distance to guide the search towards a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += np.log(edge_count[i][j] + 1) / np.log(2) * (1 / max(edge_n_used[i][j], 1))\\n\\n return updated_edge_distance\",\n \"objective\": 0.16233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Perturb the edge distances along the local optimal route by adding a random noise factor to each edge distance, the noise factor being a random value between -1 and 1, to increase the exploration space and escape from the local optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n noise_factor = np.random.uniform(-1, 1) # Add random noise to the edge distance\\n updated_edge_distance[start_node][end_node] += noise_factor\\n \\n return updated_edge_distance\",\n \"objective\": 0.17574,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution with a more aggressive update by squaring the edge count.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.ones_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n updated_edge_distance *= (1 + (edge_count ** 2) / edge_n_used)\\n\\n return updated_edge_distance\",\n \"objective\": 0.18055,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The strategy is to identify the edges in the local optimal tour that are frequently used and update their distances in the edge distance matrix to discourage using them again, thereby guiding the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_count[edge_n_used == 0] = 1 # simplified to avoid overfitting\\n\\n updated_edge_distance *= (1 + edge_count / edge_n_used)\\n\\n return updated_edge_distance\",\n \"objective\": 0.20408,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Perturb the edge distances along the local optimal route by adding a random noise factor to each edge distance, with the noise factor being a random value between -1 and 1, to escape from the local optimum and move towards a global optimum. \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i + 1]\\n edge_index = edge_n_used[start_node][end_node]\\n updated_edge_distance[start_node][end_node] += np.random.uniform(-1, 1)\\n \\n return updated_edge_distance\",\n \"objective\": 0.2165,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the sum of the frequency of each edge used in the local optimal tour and the reciprocal of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_n_used)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += (edge_count[i][j] + (1 / max(edge_n_used[i][j], 1)))\\n\\n return updated_edge_distance\",\n \"objective\": 0.04299,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to update the edge distances by taking into account the frequency of each edge used in the local optimal tour using a noise factor that depends on the squared edge count and the absolute square root of the edge count to guide the search towards a better solution in a balanced manner.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5 / (edge_count[i][j] ** 2), 0.5 / np.sqrt(edge_count[i][j]))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.07769,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a noise factor that depends on the reciprocal of the square root of the edge count and the edge distance to guide the search towards a better solution with a balanced bias towards lesser used edges and longer distances.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-1 / np.sqrt(edge_count[i][j]), 1 / np.sqrt(edge_count[i][j])) + (edge_distance[i][j] / np.max(edge_distance))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.08263,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a noise factor that depends on the edge count and the edge distance to guide the search towards a better solution with a bias towards lesser used edges and longer distances, but incorporating a decay factor to reduce the impact of noise on heavily used edges.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-1 / edge_count[i][j], 1 / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance))\\n noise_factor *= np.exp(-0.1 * edge_n_used[i][j]) # Applying decay factor\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.08494,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The strategy is to update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a noise factor that depends on the square root of the edge count and the logarithm of the edge count to guide the search towards a better solution in a balanced manner.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5 / np.sqrt(edge_count[i][j]), 0.5 / np.log(edge_count[i][j] + 1))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.08747,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a noise factor that depends on the edge count and the edge distance to guide the search towards a better solution with a bias towards lesser used edges and longer distances.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-1 / edge_count[i][j], 1 / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.0905,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The strategy is to update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a noise factor that depends on the square root of the edge count and the logarithm of the edge count to guide the search towards a better solution in a balanced manner.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5, 0.5)\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.09058,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by perturbing the edge distances randomly using a noise factor based on the sine function of the edge count to introduce variability and exploration in the search for a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-1, 1) * np.sin(edge_count[i][j])\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.09143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances in the edge distance matrix based on frequency of each edge used in the local optimal tour using a modified noise factor that depends on the edge count to guide the search towards a better solution\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5 / edge_count[i][j], 0.5 / edge_count[i][j])\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.09253,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nImplement a new algorithm that updates the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a modified noise factor that depends on the square root of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5 / np.sqrt(edge_count[i][j]), 0.5 / np.sqrt(edge_count[i][j]))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.10138,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a noise factor that depends on a custom combination of edge count and distance to guide the search towards a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5, 0.5) * edge_count[i][j] + (1 / max(edge_n_used[i][j], 1)) * (edge_distance[i][j] / np.max(edge_distance))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.02634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the occurrence of each edge used in the local optimal tour with a noise factor that depends on a custom combination of edge count, distance, and edge usage to guide the search towards a better solution using a modified scoring function with a lower noise factor, a higher weight for edge count, and a penalty for overused edges.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.5 * np.random.uniform() * (1 / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - 0.2 * (edge_n_used[i][j] / max_edge_usage)\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02789,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering the weighted combination of edge count, edge distance, and the reciprocal of edge usage, using a different predefined weighting factor to guide the search towards a better solution with a balanced bias towards different factors.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_n_used)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n weight_factor = 0.6 # Different predefined weighting factor\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += weight_factor * (edge_count[i][j] + (1 / max(edge_n_used[i][j], 1))) + (1 - weight_factor) * (edge_distance[i][j] / np.max(edge_distance))\\n\\n return updated_edge_distance\",\n \"objective\": 0.03518,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the occurrence of each edge used in the local optimal tour with a noise factor that depends on a custom combination of edge count and distance to guide the search towards a better solution using a modified scoring function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.8 * np.random.uniform() * (1 / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.03736,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the sum of the frequency of each edge used in the local optimal tour and the reciprocal of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_n_used)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += (edge_count[i][j] + (1 / max(edge_n_used[i][j], 1)))\\n\\n return updated_edge_distance\",\n \"objective\": 0.04299,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the minimum frequency of each edge used in the local optimal tour and a custom transformation of the edge count and distance, incorporating a noise factor proportional to the reciprocal of the edge count and a scaled factor based on the distance to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (1 / max(edge_count[i][j], 1)) * (edge_distance[i][j] / np.max(edge_distance))\\n scaled_factor = 0.7 * np.random.uniform(0.5, 1.5) * (1 / edge_count[i][j]) + 0.3 * (edge_distance[i][j] / np.mean(edge_distance))\\n updated_edge_distance[i][j] += scaled_factor + noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.0467,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the occurrence of each edge used in the local optimal tour with a noise factor that depends on a custom combination of edge count and distance to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.5 * np.random.uniform() * (1 / edge_count[i][j]) + (edge_distance[i][j] / np.max(edge_distance))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.0526,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances by considering the frequency of each edge used in the local optimal tour and incorporating a custom non-linear transformation of the edge count and distance, along with a normalized factor based on the reciprocal of edge usage, to guide the search towards a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n transformation_factor = (edge_count[i][j] ** 2) / (edge_distance[i][j] + 1) # Custom non-linear transformation\\n normalized_factor = (1 / max(edge_n_used[i][j], 1))\\n updated_edge_distance[i][j] += transformation_factor + normalized_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.05561,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the occurrence of each edge used in the local optimal tour with a noise factor that depends on a custom combination of edge count and edge distance to guide the search towards a better solution using a modified scoring function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.5 * np.random.uniform() * (1 / edge_count[i][j]) + 0.5 * (edge_distance[i][j] / np.max(edge_distance))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.05822,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the occurrence of each edge used in the local optimal tour with a noise factor that depends on a custom combination of edge count and distance to guide the search towards a better solution using a modified scoring function with a lower noise factor and a higher weight for edge count compared to the previous algorithm.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.5 * np.random.uniform() * (1 / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance))\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.06748,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the sum of the frequency of each edge used in the local optimal tour and the square root of the reciprocal of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_n_used)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1))))\\n\\n return updated_edge_distance\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering the combination of edge count, distance, and usage, with a focus on promoting exploration by applying a dynamic noise factor and leveraging a custom heuristics function to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02126,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by introducing a mutation factor that is dependent on the edge count, distance, and usage, aiming to encourage exploration while also considering the impact of individual edge usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n max_edge_usage = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n mutation_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / max_edge_usage) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += mutation_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by adjusting the scoring function to include a penalty factor for frequently used edges and incorporating random noise based on edge count, distance, and usage to encourage exploration towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n max_edge_usage = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / max_edge_usage) * edge_n_used[i][j] - 0.5 * edge_count[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02493,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix based on the frequency of each edge used in the local optimal tour using a noise factor that depends on a custom combination of edge count and distance to guide the search towards a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = np.random.uniform(-0.5, 0.5) * edge_count[i][j] + (1 / max(edge_n_used[i][j], 1)) * (edge_distance[i][j] / np.max(edge_distance))\\n updated_edge_distance[i][j] += noise_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.02634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating edge count, distance, and usage into the noise factor calculation, and adjusting the scoring function to include a penalty factor for frequently used edges in order to encourage exploration towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n max_edge_usage = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / max_edge_usage) * edge_n_used[i][j] - 0.5 * edge_count[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the occurrence of each edge used in the local optimal tour with a noise factor that depends on a custom combination of edge count, distance, and edge usage to guide the search towards a better solution using a modified scoring function with a lower noise factor, a higher weight for edge count, and a penalty for overused edges.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.5 * np.random.uniform() * (1 / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - 0.2 * (edge_n_used[i][j] / max_edge_usage)\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02789,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by introducing a mutation factor that is dependent on the edge count, distance, and usage, aiming to encourage exploration while also considering the impact of individual edge usage with different parameter settings for mutation factor calculation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n max_edge_usage = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n mutation_factor = (np.random.uniform(0.5, 1.5) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.5 / max_edge_usage) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += mutation_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering the combination of edge count, distance, and usage, with a focus on promoting exploration by applying a dynamic noise factor and leveraging a custom heuristics function to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n max_edge_usage = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / max_edge_usage) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.03322,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Updated based on the frequency of the edge used, non-linear transformation, normalized factor, and penalty for overused edges.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_distance)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n transformation_factor = (edge_count[i][j] ** 2) / (edge_distance[i][j] + 1) # Custom non-linear transformation\\n normalized_factor = (1 / max(edge_n_used[i][j], 1))\\n penalty = 0.5 if edge_n_used[i][j] > 1 else 0 # Penalty for overused edges\\n updated_edge_distance[i][j] += transformation_factor + normalized_factor - penalty\\n\\n return updated_edge_distance\",\n \"objective\": 0.0349,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01633,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix by incorporating a dynamic scaling factor that takes into account the frequency of edge usage, the reciprocal of the edge count, and the mean edge distance to promote exploration and improve the search for a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n scaling_factor = (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1)))) / mean_edge_distance\\n updated_edge_distance[i][j] += scaling_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the sum of the frequency of each edge used in the local optimal tour and the square root of the reciprocal of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_n_used)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1))))\\n\\n return updated_edge_distance\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering the combination of edge count, distance, and usage, with a focus on promoting exploration by applying a dynamic noise factor and leveraging a custom heuristics function to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02126,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances in the edge distance matrix by applying a dynamic weight factor that adjusts based on edge count, distance, and usage, with the intention of balancing exploration and exploitation for improved search performance.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n weight_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += weight_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by adding a noise factor to each edge based on a combination of edge count, distance, and edge usage to guide the search towards a better solution using a modified scoring function with a different noise factor formula and penalty for overused edges.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.3 * np.random.uniform() * (1 / edge_count[i][j]) + 0.7 * (edge_distance[i][j] / mean_edge_distance) - 0.1 * (edge_n_used[i][j] / max_edge_usage)\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will update the edge distances in the edge distance matrix by applying a score function that incorporates a combination of edge count, distance, and usage, with a focus on promoting exploration and balancing exploitation for improved search performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.random.uniform(0.5, 1.5) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0219,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by introducing a mutation factor that is dependent on the edge count, distance, and usage, aiming to encourage exploration while also considering the impact of individual edge usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n max_edge_usage = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n mutation_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / max_edge_usage) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += mutation_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02334,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by introducing a mutation factor that is dependent on the edge count, distance, and usage, aiming to encourage exploration while also considering the impact of individual edge usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / np.max(edge_n_used)) * edge_n_used[i][j] * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02336,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a penalty factor for overused edges and adjusting the noise factor based on the edge count and distance to guide the search towards a better solution using a modified scoring function.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n penalty_factor = 0.1 * edge_n_used[i][j] / max_edge_usage\\n noise_factor = 0.5 * np.random.uniform() - penalty_factor\\n updated_edge_distance[i][j] += noise_factor \\n updated_edge_distance[i][j] += 0.5 * (edge_distance[i][j] / mean_edge_distance)\\n \\n return updated_edge_distance\",\n \"objective\": 0.02444,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01633,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix by incorporating a dynamic scaling factor that takes into account the frequency of edge usage, the reciprocal of the edge count, and the mean edge distance to promote exploration and improve the search for a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n scaling_factor = (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1)))) / mean_edge_distance\\n updated_edge_distance[i][j] += scaling_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the sum of the frequency of each edge used in the local optimal tour and the square root of the reciprocal of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_n_used)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1))))\\n\\n return updated_edge_distance\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering the combination of edge count, distance, and usage, with a focus on promoting exploration by applying a dynamic noise factor and leveraging a custom heuristics function to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02126,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances in the edge distance matrix by applying a dynamic weight factor that adjusts based on edge count, distance, and usage, with the intention of balancing exploration and exploitation for improved search performance.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n weight_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += weight_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by adding a noise factor to each edge based on a combination of edge count, distance, and edge usage to guide the search towards a better solution using a modified scoring function with a different noise factor formula and penalty for overused edges.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.3 * np.random.uniform() * (1 / edge_count[i][j]) + 0.7 * (edge_distance[i][j] / mean_edge_distance) - 0.1 * (edge_n_used[i][j] / max_edge_usage)\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will update the edge distances in the edge distance matrix by applying a score function that incorporates a combination of edge count, distance, and usage, with a focus on promoting exploration and balancing exploitation for improved search performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.random.uniform(0.5, 1.5) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0219,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a combination of the reciprocal of the edge count, the mean edge distance, and a penalty for overused edges to encourage global exploration and discourage overexploitation for improved search performance.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n penalty_factor = (1 / edge_count[i][j]) - (0.5 * edge_n_used[i][j] / max_edge_usage)\\n updated_edge_distance[i][j] += penalty_factor\\n\\n return updated_edge_distance\",\n \"objective\": 0.02266,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by introducing a mutation factor that is dependent on the edge count, distance, and usage, aiming to encourage exploration while also considering the impact of individual edge usage.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n max_edge_usage = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n mutation_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / max_edge_usage) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += mutation_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02334,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by applying a cuckoo search-inspired method, where the update is determined by a combination of edge count, distance, usage, and a customized cuckoo function to promote global exploration and improved convergence.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n \\n # Custom cuckoo search-inspired function\\n def cuckoo_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (cuckoo_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01453,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by incorporating a pheromone-like effect, where the update is determined by edge count, distance, and usage, with the addition of a decay factor to avoid stagnation and promote exploration.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n decay_factor = 0.1\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j]) - decay_factor * updated_edge_distance[i][j]\\n\\n return updated_edge_distance\",\n \"objective\": 0.01633,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: Update the edge distances in the edge distance matrix by incorporating a dynamic scaling factor that takes into account the frequency of edge usage, the reciprocal of the edge count, and the mean edge distance to promote exploration and improve the search for a better solution.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n scaling_factor = (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1)))) / mean_edge_distance\\n updated_edge_distance[i][j] += scaling_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0164,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nUpdate the edge distances in the edge distance matrix by applying a dynamic weight factor that adjusts based on edge count, distance, and usage, with the intention of balancing exploration and exploitation for improved search performance while also incorporating a new heuristic for edge distance update.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n weight_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j] + np.log(1 + edge_count[i][j])\\n updated_edge_distance[i][j] += weight_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01837,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm combines the edge count, distance, and usage factors with a genetic function to update the edge distances for improved exploration and convergence.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n\\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n # Custom genetic algorithm-inspired function\\n def genetic_function(x):\\n a = np.random.uniform(0, 1)\\n return (x * a) / (1 + x) # Example function, can be customized\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (genetic_function(edge_count[i][j]) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.01977,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix based on the sum of the frequency of each edge used in the local optimal tour and the square root of the reciprocal of the edge count to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edge_count = np.zeros_like(edge_n_used)\\n\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n updated_edge_distance[i][j] += (edge_count[i][j] + (1 / np.sqrt(max(edge_n_used[i][j], 1))))\\n\\n return updated_edge_distance\",\n \"objective\": 0.02063,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by considering the combination of edge count, distance, and usage, with a focus on promoting exploration by applying a dynamic noise factor and leveraging a custom heuristics function to guide the search towards a better solution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / np.mean(edge_distance)) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02126,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Update the edge distances in the edge distance matrix by applying a dynamic weight factor that adjusts based on edge count, distance, and usage, with the intention of balancing exploration and exploitation for improved search performance.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n weight_factor = (np.random.uniform(0.7, 1.3) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.3 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += weight_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02171,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: Update the edge distances in the edge distance matrix by adding a noise factor to each edge based on a combination of edge count, distance, and edge usage to guide the search towards a better solution using a modified scoring function with a different noise factor formula and penalty for overused edges.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n mean_edge_distance = np.mean(edge_distance)\\n max_edge_usage = np.max(edge_n_used)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n noise_factor = 0.3 * np.random.uniform() * (1 / edge_count[i][j]) + 0.7 * (edge_distance[i][j] / mean_edge_distance) - 0.1 * (edge_n_used[i][j] / max_edge_usage)\\n updated_edge_distance[i][j] += noise_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.02174,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will update the edge distances in the edge distance matrix by applying a score function that incorporates a combination of edge count, distance, and usage, with a focus on promoting exploration and balancing exploitation for improved search performance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n edge_count = np.zeros_like(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i + 1]\\n edge_count[start][end] += 1\\n edge_count[end][start] += 1\\n \\n edge_n_used_max = np.max(edge_n_used)\\n mean_edge_distance = np.mean(edge_distance)\\n\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if edge_count[i][j] > 0:\\n score_factor = (np.random.uniform(0.5, 1.5) / edge_count[i][j]) + (edge_distance[i][j] / mean_edge_distance) - (0.6 / edge_n_used_max) * edge_n_used[i][j]\\n updated_edge_distance[i][j] += score_factor * (1 + edge_count[i][j])\\n\\n return updated_edge_distance\",\n \"objective\": 0.0219,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by adding a penalty to the edges that are frequently used in the local optimal tour. \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used[edge] += 1\\n \\n for i in range(len(updated_edge_distance)):\\n for j in range(len(updated_edge_distance)):\\n penalty = edge_n_used[(i, j)]\\n updated_edge_distance[i][j] += penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.29818,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n\\nThe new algorithm updates the edge distance matrix by penalizing the edges used in the local optimal tour, based on the number of times each edge is used in the permutation.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n edge_n_used[start_node][end_node] += 1\\n updated_edge_distance[start_node][end_node] *= (1 + edge_n_used[start_node][end_node])\\n updated_edge_distance[end_node][start_node] *= (1 + edge_n_used[start_node][end_node])\\n return updated_edge_distance\",\n \"objective\": 0.33948,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by swapping the edges in the local optimal tour while keeping track of edge usage, and returns the updated edge distance matrix.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge_n_used[local_opt_tour[i], local_opt_tour[i+1]] += 1\\n edge_n_used[local_opt_tour[i+1], local_opt_tour[i]] += 1\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] *= (1 + edge_n_used[local_opt_tour[i], local_opt_tour[i+1]])\\n updated_edge_distance[local_opt_tour[i+1], local_opt_tour[i]] *= (1 + edge_n_used[local_opt_tour[i+1], local_opt_tour[i]])\\n return updated_edge_distance\",\n \"objective\": 0.40914,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by comparing the local optimal tour with the original tour and selectively updating the distance values based on the number of times each edge is used during permutation.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i, node in enumerate(local_opt_tour[:-1]):\\n next_node = local_opt_tour[i+1]\\n updated_edge_distance[node][next_node] = edge_distance[node][next_node] + 1/(edge_n_used[node][next_node]+1)\\n return updated_edge_distance\",\n \"objective\": 0.63932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by penalizing the edges used in the local optimal tour based on the number of times they were used, in order to encourage exploration of different routes and prevent being trapped in the local optimum.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n \\n updated_edge_distance = edge_distance.copy()\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used[edge[0], edge[1]] += 1\\n edge_n_used[edge[1], edge[0]] += 1\\n updated_edge_distance[edge[0], edge[1]] += edge_n_used[edge[0], edge[1]]\\n updated_edge_distance[edge[1], edge[0]] += edge_n_used[edge[1], edge[0]]\\n \\n return updated_edge_distance\",\n \"objective\": 0.86636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm uses the local optimal tour to update the edge distance matrix by reducing the distances of the edges used in the tour.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n updated_edge_distance[edge] /= edge_n_used[edge]\\n return updated_edge_distance\",\n \"objective\": 1.7979,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm updates the edge distance matrix by adding a penalty to the distances of the edges in the local optimal tour based on their frequency of being used in the permutation, with the goal of discouraging the algorithm from getting trapped in the same local optimum. \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n frequency_penalty = 1 / (1 + edge_n_used[edge])\\n updated_edge_distance[edge] += updated_edge_distance[edge] * frequency_penalty\\n return updated_edge_distance\",\n \"objective\": 1.84289,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix based on the local optimal tour by increasing the distances of the edges used in the tour, with a higher increase for edges used more frequently.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_distance_increase = 1 + 0.1 * edge_n_used[edge]\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 2.40288,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm updates the edge distance matrix by identifying the edges used in the local optimal tour and increasing their distances by a fixed amount, and decreasing the distances of unused edges by the same amount.\\n\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n fixed_amount = 1\\n \\n for i in range(len(local_opt_tour)-1):\\n node_start = local_opt_tour[i]\\n node_end = local_opt_tour[i+1]\\n \\n updated_edge_distance[node_start][node_end] += fixed_amount\\n updated_edge_distance[node_end][node_start] += fixed_amount\\n \\n unused_edges = np.where(edge_n_used == 0)\\n updated_edge_distance[unused_edges] -= fixed_amount\\n \\n return updated_edge_distance\",\n \"objective\": 2.42812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, in order to encourage exploration of different routes and avoid being trapped in the local optimum.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n penalty = 10 # Set a penalty value for frequently used edges\\n updated_edge_distance = np.copy(edge_distance) # Create a copy of the original edge distance matrix\\n \\n # Iterate through each pair of adjacent nodes in the local optimal tour\\n for i in range(len(local_opt_tour)-1):\\n node1 = local_opt_tour[i]\\n node2 = local_opt_tour[i+1]\\n \\n # Increment the number of times the edge between the current pair of nodes has been used\\n edge_n_used[node1][node2] += 1\\n edge_n_used[node2][node1] += 1\\n \\n # Add the penalty to the distance of the edge between the current pair of nodes\\n updated_edge_distance[node1][node2] += penalty\\n updated_edge_distance[node2][node1] += penalty\\n \\n return updated_edge_distance\",\n \"objective\": 2.50401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm aims to update the edge distance matrix by considering the local optimal tour and the number of times each edge is used during the permutation process.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + 1\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + 1\\n \\n # Update the number of times the edge is used\\n edge_n_used[current_node, next_node] += 1\\n edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 2.53113,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The update_edge_distance algorithm iterates over each pair of consecutive nodes in the local optimal tour and updates the edge distance matrix by increasing the distance between those nodes.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n node1 = local_opt_tour[i]\\n node2 = local_opt_tour[i + 1]\\n updated_edge_distance[node1][node2] += 1\\n updated_edge_distance[node2][node1] += 1\\n return updated_edge_distance\",\n \"objective\": 2.54362,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"In the update_edge_distance function, we will calculate the total distance of the local optimal route and initialize the updated_edge_distance matrix with the given edge_distance matrix. Then, we will iterate through each pair of cities in the local optimal route and calculate the cost difference if the cities are swapped. If swapping the cities results in a lower cost, we will update the corresponding entries in the updated_edge_distance matrix. Finally, we will return the updated_edge_distance matrix as the output.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n total_distance = 0\\n for i in range(len(local_opt_tour)-1):\\n total_distance += edge_distance[local_opt_tour[i]][local_opt_tour[i+1]]\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n for j in range(i+2, len(local_opt_tour)-1):\\n old_cost = (edge_distance[local_opt_tour[i]][local_opt_tour[i+1]] \\n + edge_distance[local_opt_tour[j]][local_opt_tour[j+1]])\\n new_cost = (edge_distance[local_opt_tour[i]][local_opt_tour[j+1]] \\n + edge_distance[local_opt_tour[j]][local_opt_tour[i+1]])\\n if new_cost < old_cost:\\n updated_edge_distance[local_opt_tour[i]][local_opt_tour[i+1]] = (\\n edge_distance[local_opt_tour[i]][local_opt_tour[j+1]])\\n updated_edge_distance[local_opt_tour[j]][local_opt_tour[j+1]] = (\\n edge_distance[local_opt_tour[j]][local_opt_tour[i+1]])\\n updated_edge_distance[local_opt_tour[i]][local_opt_tour[j+1]] = (\\n edge_distance[local_opt_tour[j]][local_opt_tour[i+1]])\\n updated_edge_distance[local_opt_tour[j]][local_opt_tour[i+1]] = (\\n edge_distance[local_opt_tour[i]][local_opt_tour[j+1]])\\n return updated_edge_distance\",\n \"objective\": 3.07116,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: update_edge_distance function takes in the edge distance matrix, the local optimal tour, and the matrix of edge counts, and returns an updated edge distance matrix where the distances of edges used in the local optimal tour are increased by a specified increment, thereby avoiding being trapped in the local optimum.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n increment = np.max(edge_distance) * 2 # specify the increment as double the maximum edge distance\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge_idx = local_opt_tour[i:i+2] # get the indices of the edge in the local optimal tour\\n updated_edge_distance[edge_idx[0], edge_idx[1]] += increment # increase the distance of the edge by the increment\\n edge_n_used[edge_idx[0], edge_idx[1]] += 1 # increment the count of the edge used\\n\\n return updated_edge_distance\",\n \"objective\": 3.18,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distance matrix based on the local optimal tour and the number of times each edge is used during permutations, in order to avoid being trapped in the local optimum and find a tour with minimized distance.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance - (edge_n_used / edge_distance) + (edge_n_used / np.sum(edge_n_used)) * np.sum(edge_distance)\\n updated_edge_distance[np.diag_indices_from(updated_edge_distance)] = np.inf\\n return updated_edge_distance\",\n \"objective\": 3.19461,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by considering the edges in the local optimal tour and reducing their distances to encourage exploration of other routes.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour) - 1):\\n edge_index = edge_n_used[local_opt_tour[i], local_opt_tour[i+1]]\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] *= 1.1\\n updated_edge_distance[local_opt_tour[i+1], local_opt_tour[i]] *= 1.1\\n return updated_edge_distance\",\n \"objective\": 3.25973,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix based on the local optimal tour by increasing the distances between edges that are frequently used during permutation.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n edges = np.array(list(zip(local_opt_tour[:-1], local_opt_tour[1:])))\\n unique_edges, unique_counts = np.unique(edges, axis=0, return_counts=True)\\n \\n for i in range(len(unique_edges)):\\n u, v = unique_edges[i]\\n count = unique_counts[i]\\n updated_edge_distance[u][v] += count\\n \\n return updated_edge_distance\",\n \"objective\": 3.30089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm first calculates the total distance of the local optimal route. Then, it identifies the edges that are frequently used in the local optimal tour and increases their distances in the edge distance matrix. This encourages the algorithm to explore alternative routes by making the frequently used edges less favorable. The updated edge distance matrix is then returned.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n total_distance = 0\\n \\n for i in range(len(local_opt_tour) - 1):\\n total_distance += edge_distance[local_opt_tour[i]][local_opt_tour[i+1]]\\n \\n frequently_used_edges = np.where(edge_n_used > np.mean(edge_n_used))[0]\\n \\n updated_edge_distance = np.copy(edge_distance)\\n \\n for edge in frequently_used_edges:\\n updated_edge_distance[edge] += updated_edge_distance[edge] * 0.1\\n \\n return updated_edge_distance\",\n \"objective\": 3.47418,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour based on their usage frequency in the permutation.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] += edge_n_used[local_opt_tour[i], local_opt_tour[i+1]]\\n updated_edge_distance[local_opt_tour[-1], local_opt_tour[0]] += edge_n_used[local_opt_tour[-1], local_opt_tour[0]]\\n return updated_edge_distance\",\n \"objective\": 3.49348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by adding a penalty to the edges used in the local optimal tour, based on the number of times they have been used in the overall permutation.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n penalty = np.max(edge_distance) * np.max(edge_n_used) # Calculate the penalty as the maximum edge distance multiplied by the maximum times an edge has been used\\n updated_edge_distance = np.copy(edge_distance) # Create a copy of the edge distance matrix\\n\\n for i in range(len(local_opt_tour) - 1): # Iterate over the local optimal tour\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n\\n updated_edge_distance[start_node, end_node] += penalty # Add the penalty to the corresponding edge in the updated edge distance matrix\\n\\n return updated_edge_distance\",\n \"objective\": 10000000000.0,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Algorithm:\\n\\nThe new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the total number of permutations to the number of times each edge is used, but with a different parameter setting of the score function.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 1)\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.03859,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nPython code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.01 / edge_n_used_normalized\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.09324,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\nAlgorithm parameters:\\n- edge_distance: a matrix representing the distances between edges.\\n- local_opt_tour: a numpy array representing the local optimal tour of IDs.\\n- edge_n_used: a matrix representing the number of times each edge is used during permutation.\\n\\nPython code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.02 / edge_n_used_normalized # Different parameter setting, increase factor of 0.02\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.09435,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\nThe new algorithm will use a different parameter setting for the edge distance increase factor. Instead of the current factor of 0.02, we will use a factor of 0.05. The updated edge distance increase will be calculated as 1 + 0.05 / edge_n_used_normalized.\\n\\nHere is the updated Python implementation of the function:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.05 / edge_n_used_normalized # Different parameter setting, increase factor of 0.05\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.09892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the total number of permutations, but with a different parameter setting of the score function.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + 1 / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + 1 / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.13822,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently.\\n\\nPython code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_distance_increase = 1 + 0.1 / edge_n_used[edge]\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.15783,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the edges that are frequently used in the local optimal tour, but the penalty is proportional to the square root of the number of times the edge is used, making it harder for frequently used edges to accumulate penalties. \\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used[edge] += 1\\n \\n for i in range(len(updated_edge_distance)):\\n for j in range(len(updated_edge_distance)):\\n if edge_n_used[(i, j)] != 0:\\n penalty = 1 / np.sqrt(edge_n_used[(i, j)])\\n updated_edge_distance[i][j] += penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.18891,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the total number of permutations, but with a different parameter setting of the score function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + 1 / (edge_n_used[current_node, next_node] + 1)\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + 1 / (edge_n_used[next_node, current_node] + 1)\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.19925,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the edges used in the local optimal tour based on their number of times used and adjusts their distance values accordingly to encourage exploration of different routes and prevent being trapped in the local optimum. However, in this new algorithm, the constant_value is set to 15 instead of 10.\\n\\nNew algorithm code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n constant_value = 15 # Constant value to be subtracted/added to the current distance value\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n \\n edge_n_used[edge[0], edge[1]] += 1\\n edge_n_used[edge[1], edge[0]] += 1\\n \\n updated_edge_distance[edge[0], edge[1]] -= constant_value * math.log(edge_distance[edge[0], edge[1]]) * edge_n_used[edge[0], edge[1]] + constant_value * math.log(edge_n_used[edge[0], edge[1]])\\n updated_edge_distance[edge[1], edge[0]] -= constant_value * math.log(edge_distance[edge[1], edge[0]]) * edge_n_used[edge[1], edge[0]] + constant_value * math.log(edge_n_used[edge[1], edge[0]])\\n \\n return updated_edge_distance\",\n \"objective\": 0.20855,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the total number of permutations, with a higher weight factor for the score function.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Set the weight factor for the score function\\n weight_factor = 0.75\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + weight_factor / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + weight_factor / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.21234,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the total number of permutations, but with a different parameter setting of the score function.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + (1 / (edge_n_used[current_node, next_node] + 1)) * (total_permutations - edge_n_used[current_node, next_node]) / total_permutations\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + (1 / (edge_n_used[next_node, current_node] + 1)) * (total_permutations - edge_n_used[next_node, current_node]) / total_permutations\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.23305,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the edges used in the local optimal tour based on their number of times used and subtracts a constant multiplied by the logarithm of their current distance value from their distance value, and also adds a constant multiplied by the logarithm of their number of times used, in order to encourage exploration of different routes and prevent being trapped in the local optimum. However, in this new algorithm, the constant_value is set to 10 instead of 5.\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n constant_value = 10 # Constant value to be subtracted/added to the current distance value\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n \\n edge_n_used[edge[0], edge[1]] += 1\\n edge_n_used[edge[1], edge[0]] += 1\\n \\n updated_edge_distance[edge[0], edge[1]] -= constant_value * math.log(edge_distance[edge[0], edge[1]]) * edge_n_used[edge[0], edge[1]] + constant_value * math.log(edge_n_used[edge[0], edge[1]])\\n updated_edge_distance[edge[1], edge[0]] -= constant_value * math.log(edge_distance[edge[1], edge[0]]) * edge_n_used[edge[1], edge[0]] + constant_value * math.log(edge_n_used[edge[1], edge[0]])\\n \\n return updated_edge_distance\",\n \"objective\": 0.24391,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the total number of permutations, with a higher weight factor for the score function. The new algorithm will use a different weight factor for the score function, defined as a fraction of the maximum edge distance in the matrix.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Set the weight factor for the score function as a fraction of the maximum edge distance\\n weight_factor = 0.5 * np.max(edge_distance)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + weight_factor / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + weight_factor / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.24574,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a larger penalty to the edges that are frequently used in the local optimal tour, discouraging the algorithm from using them in future iterations.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used[edge] += 1\\n \\n for i in range(len(updated_edge_distance)):\\n for j in range(len(updated_edge_distance)):\\n penalty = edge_n_used[(i, j)] ** 2 # Updated penalty by taking the square of the edge_n_used\\n updated_edge_distance[i][j] += penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.26474,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the edges used in the local optimal tour based on their number of times used and subtracts a constant multiplied by the logarithm of their current distance value from their distance value, and also adds a constant multiplied by the logarithm of their number of times used, in order to encourage exploration of different routes and prevent being trapped in the local optimum.\\n\\nNew algorithm code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\nimport math\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n constant_value = 5 # Constant value to be subtracted/added to the current distance value\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n \\n edge_n_used[edge[0], edge[1]] += 1\\n edge_n_used[edge[1], edge[0]] += 1\\n \\n updated_edge_distance[edge[0], edge[1]] -= constant_value * math.log(edge_distance[edge[0], edge[1]]) * edge_n_used[edge[0], edge[1]] + constant_value * math.log(edge_n_used[edge[0], edge[1]])\\n updated_edge_distance[edge[1], edge[0]] -= constant_value * math.log(edge_distance[edge[1], edge[0]]) * edge_n_used[edge[1], edge[0]] + constant_value * math.log(edge_n_used[edge[1], edge[0]])\\n \\n return updated_edge_distance\",\n \"objective\": 0.26732,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the edges used in the local optimal tour based on the squared cumulative inverse distance (1/distance) of each edge in the permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n edge_n_used[start_node][end_node] += (1/edge_distance[start_node][end_node])**2\\n updated_edge_distance[start_node][end_node] += edge_n_used[start_node][end_node]\\n updated_edge_distance[end_node][start_node] += edge_n_used[start_node][end_node]\\n return updated_edge_distance\",\n \"objective\": 0.27005,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm penalizes the edges used in the local optimal tour based on their number of times used and adds a constant multiplied by the inverse of their current distance value squared to their distance value in order to encourage exploration of different routes and prevent being trapped in the local optimum.\\n\\nCode:\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n constant_value = 10 # Constant value to be added to the current distance value\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n \\n edge_n_used[edge[0], edge[1]] += 1\\n edge_n_used[edge[1], edge[0]] += 1\\n \\n updated_edge_distance[edge[0], edge[1]] += constant_value * (1 / (edge_distance[edge[0], edge[1]])**2) * edge_n_used[edge[0], edge[1]]\\n updated_edge_distance[edge[1], edge[0]] += constant_value * (1 / (edge_distance[edge[1], edge[0]])**2) * edge_n_used[edge[1], edge[0]]\\n \\n return updated_edge_distance\",\n \"objective\": 0.27926,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the edges used in the local optimal tour based on the squared cumulative distance of each edge in the permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n start_node = local_opt_tour[i]\\n end_node = local_opt_tour[i+1]\\n edge_n_used[start_node][end_node] += edge_distance[start_node][end_node]**2\\n updated_edge_distance[start_node][end_node] += edge_n_used[start_node][end_node]\\n updated_edge_distance[end_node][start_node] += edge_n_used[start_node][end_node]\\n return updated_edge_distance\",\n \"objective\": 0.28727,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the edges used in the local optimal tour based on their number of times used and subtracts a constant multiplied by the logarithm of their current distance value from their distance value, and also adds a constant multiplied by the logarithm of their number of times used, in order to encourage exploration of different routes and prevent being trapped in the local optimum.\",\n \"code\": \"import numpy as np\\r\\nimport math\\r\\n\\r\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\r\\n updated_edge_distance = edge_distance.copy()\\r\\n \\r\\n constant_value = 10 # Constant value to be subtracted/added to the current distance value\\r\\n \\r\\n for i in range(len(local_opt_tour) - 1):\\r\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\r\\n \\r\\n edge_n_used[edge[0], edge[1]] += 1\\r\\n edge_n_used[edge[1], edge[0]] += 1\\r\\n \\r\\n # Updated score function\\r\\n updated_edge_distance[edge[0], edge[1]] -= constant_value * math.log(edge_distance[edge[0], edge[1]]) * (edge_n_used[edge[0], edge[1]] + 1) + constant_value * math.log(edge_n_used[edge[0], edge[1]])\\r\\n updated_edge_distance[edge[1], edge[0]] -= constant_value * math.log(edge_distance[edge[1], edge[0]]) * (edge_n_used[edge[1], edge[0]] + 1) + constant_value * math.log(edge_n_used[edge[1], edge[0]])\\r\\n \\r\\n return updated_edge_distance\",\n \"objective\": 0.28993,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the edges used in the local optimal tour based on their number of times used and adds a constant multiplied by the inverse of their current distance value to their distance value in order to encourage exploration of different routes and prevent being trapped in the local optimum.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n constant_value = 10 # Constant value to be added to the current distance value\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n \\n edge_n_used[edge[0], edge[1]] += 1\\n edge_n_used[edge[1], edge[0]] += 1\\n \\n updated_edge_distance[edge[0], edge[1]] += constant_value * (1 / edge_distance[edge[0], edge[1]]) * edge_n_used[edge[0], edge[1]]\\n updated_edge_distance[edge[1], edge[0]] += constant_value * (1 / edge_distance[edge[1], edge[0]]) * edge_n_used[edge[1], edge[0]]\\n \\n return updated_edge_distance\",\n \"objective\": 0.29682,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with square-root normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.sqrt(edge_n_used_normalized + 2) # Different parameter setting, increase factor of 3.0 with square-root normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with power normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.power(edge_n_used_normalized + 3, 0.8) # Different parameter setting, increase factor of 3.0 with power normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01223,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on the utilization ratio and the number of times each edge has been used. The weight is calculated as the inverse of the utilization ratio plus the square root of the number of times the edge has been used.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Calculate the weight of the current edge\\n weight = constant / utilization_ratio + np.sqrt(edge_n_used[current_node, next_node])\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + weight\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + weight\\n \\n return updated_edge_distance\",\n \"objective\": 0.01233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on its utilization ratio. The weight is calculated as the inverse of the utilization ratio plus a constant.\\n\\nPython implementation:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / utilization_ratio\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / utilization_ratio\\n \\n return updated_edge_distance\",\n \"objective\": 0.01277,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with square-root normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.sqrt(edge_n_used_normalized + 2) # Different parameter setting, increase factor of 3.0 with square-root normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with power normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.power(edge_n_used_normalized + 3, 0.8) # Different parameter setting, increase factor of 3.0 with power normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01223,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage and a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 0.1 / np.power(edge_n_used_normalized + 3, 0.5) # Different parameter setting, increase factor of 0.1 with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 0.1 / np.power(edge_n_used_normalized + 3, 0.5) # Different parameter setting, increase factor of 0.1 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a new dynamic constant, calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 0.1 / np.power(edge_n_used_normalized + 3, 0.5) # Different parameter setting, increase factor of 0.1 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a new dynamic constant, calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 0.1 / np.power(edge_n_used_normalized + 3, 0.5) # Different parameter setting, increase factor of 0.1 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01158,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a new dynamic constant, calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00645,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.011,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 0.1 / np.power(edge_n_used_normalized + 3, 0.5) # Different parameter setting, increase factor of 0.1 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.sqrt(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01158,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00645,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 5 + 1 / (edge_n_used_normalized + 0.2) + 0.3 * np.log(edge_n_used_normalized + 0.2)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 1 / (edge_n_used_normalized + 0.2) + 0.3 * np.log(edge_n_used_normalized + 0.2)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00941,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.011,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 0.1 / np.power(edge_n_used_normalized + 3, 0.5) # Different parameter setting, increase factor of 0.1 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01127,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00645,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour based on their normalized usage, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nPython Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2.5 + 0.5 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.5 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00657,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 5 + 1 / (edge_n_used_normalized + 0.2) + 0.3 * np.log(edge_n_used_normalized + 0.2)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 1 / (edge_n_used_normalized + 0.2) + 0.3 * np.log(edge_n_used_normalized + 0.2)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00941,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.011,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure: \\n\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage using a different parameter setting of the score function.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nUpdated Python implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5.0 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00239,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 / (edge_n_used_normalized + 2) + np.log(edge_n_used_normalized + 3) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00645,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour based on their normalized usage, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nPython Implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2.5 + 0.5 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.5 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00657,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 3 + 1 / (edge_n_used_normalized + 1) + 0.3 * np.log(edge_n_used_normalized + 1)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3 + 1 / (edge_n_used_normalized + 1) + 0.3 * np.log(edge_n_used_normalized + 1)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00892,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 5 + 1 / (edge_n_used_normalized + 0.2) + 0.3 * np.log(edge_n_used_normalized + 0.2)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 5 + 1 / (edge_n_used_normalized + 0.2) + 0.3 * np.log(edge_n_used_normalized + 0.2)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00941,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 10, 0.6) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00999,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Use the following parameter settings for the score function:\\n - edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1)\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5a. Calculate the increase factor for the edge distance based on the normalized usage, using the different parameter setting (increase factor of 0.3 with power normalization).\\n5b. If the normalized usage is less than or equal to 0.5, add 0.2 to the increase factor.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.3 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.3 with power normalization\\n if edge_n_used_normalized <= 0.5:\\n edge_distance_increase += 0.2\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01075,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The updated algorithm modifies the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3 / (edge_n_used_normalized + 3) + np.log(edge_n_used_normalized + 4) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.011,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"Algorithm Description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a fixed constant. The fixed constant is calculated as the sum of the average edge distance multiplied by the number of edges.\\n\\nCode:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the fixed constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * total_permutations\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.0142,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a fixed constant, but with a different parameter setting of the score function.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Initialize the fixed constant\\n constant = 10\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01692,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 0.1 / np.sqrt(edge_n_used_normalized + 1) # Different parameter setting, increase factor of 0.1 with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0182,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the number of times each edge is used, but with a different parameter setting of the score function. The updated algorithm calculates the score for updating the edge distance between nodes using the formula: score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 5)\\n\\nPython Implementation:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 5) # Different parameter setting\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.0195,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the total number of permutations, multiplied by the inverse of the edge distance between the current and next node.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + (1 / (edge_n_used[current_node, next_node] + 1)) * (1 / edge_distance[current_node, next_node])\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + (1 / (edge_n_used[next_node, current_node] + 1)) * (1 / edge_distance[next_node, current_node])\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.02634,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the total number of permutations, with the exponential of the score function.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + np.exp(-edge_n_used[current_node, next_node] / total_permutations)\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + np.exp(-edge_n_used[next_node, current_node] / total_permutations)\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.02652,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the number of times each edge is used, but with a different parameter setting of the score function.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 2) # Different parameter setting\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.02803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm aims to update the edge distance matrix by considering the local optimal tour and the number of times each edge is used, but with a different parameter setting of the score function.\\nThe updated algorithm calculates the score for updating the edge distance between nodes using the formula:\\nscore = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 3)\\n\\nPython Implementation:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 3) # Different parameter setting\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.03295,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used infrequently.\\n\\nThe updated algorithm code is as follows:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n\\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the sum of all edge usage counts\\n total_edge_usage = np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the penalty term based on the edge usage (using different parameter settings)\\n penalty = 1 - ((edge_n_used[current_node, next_node] ** 2) / (total_edge_usage ** 2))\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.03454,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.03493,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm:\\n\\nThe new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the total number of permutations to the number of times each edge is used, but with a different parameter setting of the score function.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 1)\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.03859,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used infrequently, using a different parameter for the penalty calculation.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n \\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - ((edge_n_used[current_node, next_node] ** 3) / (total_edge_usage ** 3))\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n \\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.04012,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely. In addition, the new algorithm introduces a weight parameter to adjust the influence of the penalty term on the updated edge distance.\\n\\n\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n weight = 0.5 # Set the weight parameter, adjust as needed\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = (1 - (edge_n_used[current_node, next_node] / total_edge_usage)) * weight\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.04297,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used infrequently. In this algorithm, the penalty term is updated to include a term that increases the penalty for edges that are used less frequently.\\n\\nNew algorithm steps:\\n1. Create a copy of the edge distance and edge used matrices.\\n2. Get the number of nodes in the tour.\\n3. Calculate the sum of all edge usage counts.\\n4. Iterate over each node in the tour.\\n5. Get the current node ID and the next node ID.\\n6. Calculate the penalty term based on the edge usage.\\n7. Update the penalty term to include a term that increases the penalty for edges that are used less frequently.\\n8. Update the edge distance between the current and next node with the updated penalty.\\n9. Update the edge distance between the next and current node with the updated penalty.\\n10. Return the updated edge distance matrix.\\n\\nUpdated algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n\\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the sum of all edge usage counts\\n total_edge_usage = np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the penalty term based on the edge usage (using different parameter settings)\\n penalty = 1 - ((edge_n_used[current_node, next_node] ** 2) / (total_edge_usage ** 2))\\n \\n # Update the penalty term to include a term that increases the penalty for edges that are used less frequently\\n penalty += 1 - (edge_n_used[current_node, next_node] / np.sum(edge_n_used))\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.04675,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the total number of permutations to the number of times each edge is used, but with a different parameter setting of the score function.\\n\\n```Python\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = total_permutations / (edge_n_used[current_node, next_node] + 1)\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.04775,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the number of times each edge is used, using a different parameter setting of the score function. In this new algorithm, the score is computed as the reciprocal of the square root of the number of times an edge is used, plus a constant factor for regularization.\\n\\nNew Algorithm Steps:\\n1. Create a copy of the edge distance and edge used matrices.\\n2. Get the number of nodes in the tour.\\n3. Iterate over each node in the tour.\\n4. Get the current node ID and the next node ID.\\n5. Compute the score for updating the edge distance using the formula: score = 1 / sqrt(edge_n_used[current_node, next_node] + 1) + constant_factor, where constant_factor is a positive constant for regularization.\\n6. Update the edge distance between the current and next node by adding the computed score.\\n7. Update the edge distance between the next and current node by adding the computed score.\\n8. Increment the number of times the edge is used by 1.\\n9. Return the updated edge distance matrix.\\n\\nPython Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\nfrom math import sqrt\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Set the constant factor for regularization\\n constant_factor = 0.1\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = 1 / sqrt(edge_n_used[current_node, next_node] + 1) + constant_factor\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.05273,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function where the edge distance increase is computed as 1 + 0.2 / edge_n_used_normalized.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.2 / edge_n_used_normalized\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.06979,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function where the edge distance increase is computed as 1 + 0.1 / edge_n_used_normalized.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.1 / edge_n_used_normalized\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.07062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nPython code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.04 / edge_n_used_normalized # Different parameter setting, increase factor of 0.04\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.0877,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently. Furthermore, the increase in distance is proportional to the inverse of the edge's frequency, promoting exploration of less frequently used edges.\\n\\nPython code:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_frequency = edge_n_used[edge]\\n edge_distance_increase = 1 + 1 / edge_frequency\\n updated_edge_distance[edge] += edge_distance_increase\\n return updated_edge_distance\",\n \"objective\": 0.09059,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nUpdated Python code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 10 + (1 / np.sqrt(edge_n_used_normalized + 1)) # Modified parameter setting, increase factor of 1 with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01362,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a fixed constant. The fixed constant is calculated as the sum of the average edge distance multiplied by the number of edges.\\n\\nCode:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the fixed constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * total_permutations\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.0142,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a constant that is the sum of the maximum edge distance multiplied by the number of edges, divided by the average utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n maximum_edge_distance = np.amax(edge_distance)\\n average_utilization_ratio = np.mean(edge_n_used / total_permutations)\\n constant = (maximum_edge_distance * total_permutations) / average_utilization_ratio\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nUpdated Python code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 10 + (2 / np.sqrt(edge_n_used_normalized + 1)) # Modified parameter setting, increase factor of 2 with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01473,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 0.5 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.5 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01527,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely and uses a different penalty factor for edges that are used frequently, with the parameter settings of the score function being penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * ((total_edge_usage / total_permutations) + 0.2). \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * ((total_edge_usage / total_permutations) + 0.2)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01607,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nPython code:\\n\\n```\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.05 / np.power(edge_n_used_normalized + 1, 0.75) # Different parameter setting, increase factor of 0.05 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a fixed constant, but with a different parameter setting of the score function.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Initialize the fixed constant\\n constant = 10\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01692,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 0.2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.sqrt(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.sqrt(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01803,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 0.1 / np.sqrt(edge_n_used_normalized + 1) # Different parameter setting, increase factor of 0.1 with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0182,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm increases the distances of the edges used in the local optimal tour based on the number of times each edge is used during permutation, with a different parameter setting of the score function: edge_distance_increase = 1 + 0.1 / np.power(edge_n_used_normalized + 1, 0.9).\\n\\nPython code:\\n\\n```\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.1 / np.power(edge_n_used_normalized + 1, 0.9) # Different parameter setting, increase factor of 0.1 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01845,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using a different parameter setting for the score function: 1 + 0.5 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.5 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0194,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the number of times each edge is used, but with a different parameter setting of the score function. The updated algorithm calculates the score for updating the edge distance between nodes using the formula: score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 5)\\n\\nPython Implementation:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Compute the score for updating the edge distance\\n score = (total_permutations - edge_n_used[current_node, next_node]) / (edge_n_used[current_node, next_node] + 5) # Different parameter setting\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + score\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + score\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.0195,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently. The new parameter setting for the score function is 2 + 1 / (edge_n_used_normalized + 1)**2.\\n\\nPython Implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / ((edge_n_used_normalized + 1)**2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01951,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a squared constant. The constant is calculated as the sum of the average edge distance multiplied by the number of edges, divided by the squared average utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the squared constant\\n average_edge_distance = np.mean(edge_distance)\\n average_utilization_ratio = np.mean(edge_n_used / total_permutations)\\n constant = (average_edge_distance * total_permutations) / (average_utilization_ratio ** 2)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01965,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The updated algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function that takes the logarithm of edge_n_used_normalized as the normalization factor.\\n\\nUpdated Python code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 10 + (2 / np.log(edge_n_used_normalized + 1)) # Modified parameter setting, increase factor of 2 with logarithmic normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01991,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function. The updated algorithm includes a different parameter setting for the score function, given by the equation: 1 + 1 / (edge_n_used_normalized + 1) + 0.5 * np.log(edge_n_used_normalized + 1).\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 1 / (edge_n_used_normalized + 1) + 0.5 * np.log(edge_n_used_normalized + 1) # Different parameter setting in score function\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.02107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently. The new parameter setting for the score function is 2 + 1 / (edge_n_used_normalized + 1) + 0.5 * np.log(edge_n_used_normalized + 1).\\n\\nPython Implementation:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.5 * np.log(edge_n_used_normalized + 1) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.02206,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a constant. The constant is calculated as the sum of the average edge distance multiplied by the number of edges, divided by the maximum utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n average_edge_distance = np.mean(edge_distance)\\n max_utilization_ratio = np.max(edge_n_used / total_permutations)\\n constant = (average_edge_distance * num_nodes) / max_utilization_ratio\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n\\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function. The new parameter settings make the increase factor smaller for more frequently used edges.\\n\\nUpdated Python code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 10 + (1 / np.sqrt(edge_n_used_normalized + 1)) # Modified parameter setting, increase factor with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01362,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2.5 + 0.15 / np.power(edge_n_used_normalized + 2, 0.8) # Different parameter setting, increase factor of 0.15 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a fixed constant. The fixed constant is calculated as the sum of the average edge distance multiplied by the number of edges.\\n\\nCode:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the fixed constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * total_permutations\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.0142,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a constant that is the sum of the maximum edge distance multiplied by the number of edges, divided by the average utilization ratio of edges in the current tour.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n maximum_edge_distance = np.amax(edge_distance)\\n average_utilization_ratio = np.mean(edge_n_used / total_permutations)\\n constant = (maximum_edge_distance * total_permutations) / average_utilization_ratio\\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n return updated_edge_distance\",\n \"objective\": 0.01428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function. The new parameter settings for the score function are 0.3 + 1 / (edge_n_used_normalized + 1) + 0.15 * np.sqrt(edge_n_used_normalized + 1).\\n\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.3 + 1 / (edge_n_used_normalized + 1) + 0.15 * np.sqrt(edge_n_used_normalized + 1) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01444,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nUpdated Python code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 10 + (2 / np.sqrt(edge_n_used_normalized + 1)) # Modified parameter setting, increase factor of 2 with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01473,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently. The new parameter setting for the score function is 2 + 1 / ((edge_n_used_normalized + 1)**3).\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / ((edge_n_used_normalized + 1)**3) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 0.5 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.5 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01527,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 2.0 with power normalization, and adding a constant base increase factor of 0.5).\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.5 + 2.0 / np.power(edge_n_used_normalized + 2, 0.8) # Different parameter setting, increase factor of 2.0 with power normalization and a constant base increase factor of 0.5\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01555,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely and uses a different penalty factor for edges that are used frequently, with the parameter settings of the score function being penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * ((total_edge_usage / total_permutations) + 0.2). \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * ((total_edge_usage / total_permutations) + 0.2)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01607,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nPython code:\\n\\n```\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.05 / np.power(edge_n_used_normalized + 1, 0.75) # Different parameter setting, increase factor of 0.05 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 0.7 + 1 / (edge_n_used_normalized + 0.5) + 0.05 * np.log(edge_n_used_normalized + 0.5).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.7 + 1 / (edge_n_used_normalized + 0.5) + 0.05 * np.log(edge_n_used_normalized + 0.5) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function. The new parameter settings for the score function are 0.25 + 1 / (edge_n_used_normalized + 0.5) + 0.2 * np.sqrt(edge_n_used_normalized + 1).\\n\\nPython Implementation:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.25 + 1 / (edge_n_used_normalized + 0.5) + 0.2 * np.sqrt(edge_n_used_normalized + 1) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0166,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a fixed constant, but with a different parameter setting of the score function.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Initialize the fixed constant\\n constant = 10\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01692,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 0.8 + 1 / (edge_n_used_normalized + 0.5) + 0.2 * np.log(edge_n_used_normalized + 0.5).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.8 + 1 / (edge_n_used_normalized + 0.5) + 0.2 * np.log(edge_n_used_normalized + 0.5) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01788,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 0.2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.sqrt(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.sqrt(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01803,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with power normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.power(edge_n_used_normalized + 3, 0.8) # Different parameter setting, increase factor of 3.0 with power normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01223,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on its utilization ratio. The weight is calculated as the inverse of the utilization ratio plus a constant.\\n\\nPython implementation:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / utilization_ratio\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / utilization_ratio\\n \\n return updated_edge_distance\",\n \"objective\": 0.01277,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a constant. The constant is calculated as the sum of the average edge distance multiplied by the number of edges, divided by the maximum utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n average_edge_distance = np.mean(edge_distance)\\n max_utilization_ratio = np.max(edge_n_used / total_permutations)\\n constant = (average_edge_distance * num_nodes) / max_utilization_ratio\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n\\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01318,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function. The new parameter settings make the increase factor smaller for more frequently used edges.\\n\\nUpdated Python code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 10 + (1 / np.sqrt(edge_n_used_normalized + 1)) # Modified parameter setting, increase factor with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01362,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2.5 + 0.15 / np.power(edge_n_used_normalized + 2, 0.8) # Different parameter setting, increase factor of 0.15 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm Description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a fixed constant. The fixed constant is calculated as the sum of the average edge distance multiplied by the number of edges.\\n\\nCode:\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the fixed constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * total_permutations\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.0142,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a constant that is the sum of the maximum edge distance multiplied by the number of edges, divided by the average utilization ratio of edges in the current tour.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n maximum_edge_distance = np.amax(edge_distance)\\n average_utilization_ratio = np.mean(edge_n_used / total_permutations)\\n constant = (maximum_edge_distance * total_permutations) / average_utilization_ratio\\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n return updated_edge_distance\",\n \"objective\": 0.01428,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function. The new parameter settings for the score function are 0.3 + 1 / (edge_n_used_normalized + 1) + 0.15 * np.sqrt(edge_n_used_normalized + 1).\\n\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.3 + 1 / (edge_n_used_normalized + 1) + 0.15 * np.sqrt(edge_n_used_normalized + 1) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01444,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter settings of the score function.\\n\\nUpdated Python code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 10 + (2 / np.sqrt(edge_n_used_normalized + 1)) # Modified parameter setting, increase factor of 2 with square root normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01473,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently. The new parameter setting for the score function is 2 + 1 / ((edge_n_used_normalized + 1)**3).\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / ((edge_n_used_normalized + 1)**3) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01475,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 0.5 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.5 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01527,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 2.0 with power normalization, and adding a constant base increase factor of 0.5).\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 0.5 + 2.0 / np.power(edge_n_used_normalized + 2, 0.8) # Different parameter setting, increase factor of 2.0 with power normalization and a constant base increase factor of 0.5\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01555,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + 2 + 0.2 * np.log(edge_n_used_normalized + 1). (Changed parameter setting)\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + 2 + 0.2 * np.log(edge_n_used_normalized + 1) # Changed parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01566,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely and uses a different penalty factor for edges that are used frequently, with the parameter settings of the score function being penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * ((total_edge_usage / total_permutations) + 0.2). \\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * ((total_edge_usage / total_permutations) + 0.2)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01607,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nPython code:\\n\\n```\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 + 0.05 / np.power(edge_n_used_normalized + 1, 0.75) # Different parameter setting, increase factor of 0.05 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01616,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a different fixed constant. The fixed constant is calculated as the sum of the maximum edge distance multiplied by the number of edges.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the fixed constant\\n max_edge_distance = np.max(edge_distance)\\n constant = max_edge_distance * total_permutations\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01629,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with square-root normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.sqrt(edge_n_used_normalized + 2) # Different parameter setting, increase factor of 3.0 with square-root normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with power normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.power(edge_n_used_normalized + 3, 0.8) # Different parameter setting, increase factor of 3.0 with power normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01223,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on the utilization ratio and the number of times each edge has been used. The weight is calculated as the inverse of the utilization ratio plus the square root of the number of times the edge has been used.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Calculate the weight of the current edge\\n weight = constant / utilization_ratio + np.sqrt(edge_n_used[current_node, next_node])\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + weight\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + weight\\n \\n return updated_edge_distance\",\n \"objective\": 0.01233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on its utilization ratio. The weight is calculated as the inverse of the utilization ratio plus a constant.\\n\\nPython implementation:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / utilization_ratio\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / utilization_ratio\\n \\n return updated_edge_distance\",\n \"objective\": 0.01277,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a constant. The constant is calculated as the sum of the average edge distance multiplied by the number of edges, divided by the maximum utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n average_edge_distance = np.mean(edge_distance)\\n max_utilization_ratio = np.max(edge_n_used / total_permutations)\\n constant = (average_edge_distance * num_nodes) / max_utilization_ratio\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n\\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01318,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with square-root normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.sqrt(edge_n_used_normalized + 2) # Different parameter setting, increase factor of 3.0 with square-root normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with power normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.power(edge_n_used_normalized + 3, 0.8) # Different parameter setting, increase factor of 3.0 with power normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01223,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on the utilization ratio and the number of times each edge has been used. The weight is calculated as the inverse of the utilization ratio plus the square root of the number of times the edge has been used.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Calculate the weight of the current edge\\n weight = constant / utilization_ratio + np.sqrt(edge_n_used[current_node, next_node])\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + weight\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + weight\\n \\n return updated_edge_distance\",\n \"objective\": 0.01233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on its utilization ratio. The weight is calculated as the inverse of the utilization ratio plus a constant.\\n\\nPython implementation:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / utilization_ratio\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / utilization_ratio\\n \\n return updated_edge_distance\",\n \"objective\": 0.01277,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a parameter defined as the sum of the maximum edge distance multiplied by the number of edges, divided by the maximum utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the parameter\\n max_edge_distance = np.max(edge_distance)\\n max_utilization_ratio = np.max(edge_n_used / total_permutations)\\n param = (max_edge_distance * num_nodes) / max_utilization_ratio\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + param / edge_n_used[current_node, next_node]\\n\\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + param / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01318,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with square-root normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.sqrt(edge_n_used_normalized + 2) # Different parameter setting, increase factor of 3.0 with square-root normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with power normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.power(edge_n_used_normalized + 3, 0.8) # Different parameter setting, increase factor of 3.0 with power normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01223,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on the utilization ratio and the number of times each edge has been used. The weight is calculated as the inverse of the utilization ratio plus the square root of the number of times the edge has been used.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Calculate the weight of the current edge\\n weight = constant / utilization_ratio + np.sqrt(edge_n_used[current_node, next_node])\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + weight\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + weight\\n \\n return updated_edge_distance\",\n \"objective\": 0.01233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on its utilization ratio. The weight is calculated as the inverse of the utilization ratio plus a constant.\\n\\nPython implementation:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / utilization_ratio\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / utilization_ratio\\n \\n return updated_edge_distance\",\n \"objective\": 0.01277,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a parameter defined as the sum of the maximum edge distance multiplied by the number of edges, divided by the maximum utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the parameter\\n max_edge_distance = np.max(edge_distance)\\n max_utilization_ratio = np.max(edge_n_used / total_permutations)\\n param = (max_edge_distance * num_nodes) / max_utilization_ratio\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + param / edge_n_used[current_node, next_node]\\n\\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + param / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01318,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nAlgorithm procedure:\\n1. Initialize an empty matrix named \\\"updated_edge_distance\\\" to store the updated edge distances.\\n2. Iterate through each edge in the \\\"local_opt_tour\\\" except for the last node.\\n3. Get the current edge and its reverse edge.\\n4. Calculate the normalized usage of the edge by dividing the number of times the edge is used by the maximum usage of any edge.\\n5. Calculate the increase factor for the edge distance based on the normalized usage.\\n6. Update the edge distance in the \\\"updated_edge_distance\\\" matrix by adding the increase factor to the current edge distance and its reverse edge distance.\\n7. Return the \\\"updated_edge_distance\\\" matrix as the final result.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 3.5 + 0.2 / np.power(edge_n_used_normalized + 5, 0.7) # Different parameter setting, increase factor of 0.2 with power normalization\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.00968,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 2 + 1 / (edge_n_used_normalized + 1) + 0.1 * np.log(edge_n_used_normalized + 1) # Different parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.0107,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function.\\n\\nMain Steps:\\n1. Create a copy of the input edge distance matrix and assign it to a variable named 'updated_edge_distance'.\\n2. Iterate through the local optimal tour, except for the last element.\\n3. For each iteration, obtain the edge by taking the current element and the next element in the local optimal tour.\\n4. Calculate the edge_n_used_normalized value by dividing the number of times the edge is used by the maximum number of times any edge is used.\\n5. Calculate the edge_distance_increase by using the following parameter setting for the score function: 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2).\\n6. Update the distance of the edge in 'updated_edge_distance' by adding the edge_distance_increase.\\n7. Update the distance of the reverse edge in 'updated_edge_distance' as well.\\n8. Return the updated_edge_distance.\\n\\nPython Implementation:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1 / (edge_n_used_normalized + 1) + np.log(edge_n_used_normalized + 2) # New parameter setting\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01114,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm aims to update the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to the sum of all edge usage counts, with the addition of a penalty term that penalizes edges that are used rarely, and uses a different penalty factor for edges that are used frequently.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n total_edge_usage = np.sum(edge_n_used)\\n \\n for i in range(num_nodes):\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes]\\n \\n penalty = 1 - (edge_n_used[current_node, next_node] / total_edge_usage) * (total_edge_usage / total_permutations)\\n \\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + penalty\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01189,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a dynamic constant. The dynamic constant is calculated as the average edge distance multiplied by the number of used edges in the local optimal tour.\\n\\nNew algorithm in Python:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance and edge used matrices\\n updated_edge_distance = np.copy(edge_distance)\\n updated_edge_n_used = np.copy(edge_n_used)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n \\n # Calculate the dynamic constant\\n average_edge_distance = np.mean(edge_distance)\\n constant = average_edge_distance * np.sum(edge_n_used)\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / edge_n_used[current_node, next_node]\\n \\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / edge_n_used[next_node, current_node]\\n \\n # Update the number of times the edge is used\\n updated_edge_n_used[current_node, next_node] += 1\\n updated_edge_n_used[next_node, current_node] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 0.01199,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with square-root normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.sqrt(edge_n_used_normalized + 2) # Different parameter setting, increase factor of 3.0 with square-root normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01207,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The modified algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour. The increase in distance is based on the number of times each edge is used during permutation, with a higher increase for edges used less frequently, using a different parameter setting of the score function (edge distance increase factor of 3.0 with power normalization, and adding a constant base increase factor of 1.0).\\n\\nPython code:\\n\\n``` \\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n edge_n_used_normalized = edge_n_used[edge] / np.max(edge_n_used)\\n edge_distance_increase = 1.0 + 3.0 / np.power(edge_n_used_normalized + 3, 0.8) # Different parameter setting, increase factor of 3.0 with power normalization and a constant base increase factor of 1.0\\n updated_edge_distance[edge] += edge_distance_increase\\n updated_edge_distance[edge[::-1]] += edge_distance_increase # Update the reverse edge as well\\n return updated_edge_distance\",\n \"objective\": 0.01223,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on the utilization ratio and the number of times each edge has been used. The weight is calculated as the inverse of the utilization ratio plus the square root of the number of times the edge has been used.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Calculate the weight of the current edge\\n weight = constant / utilization_ratio + np.sqrt(edge_n_used[current_node, next_node])\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + weight\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + weight\\n \\n return updated_edge_distance\",\n \"objective\": 0.01233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and a weight assigned to each edge based on its utilization ratio. The weight is calculated as the inverse of the utilization ratio plus a constant.\\n\\nPython implementation:\\n\\n```\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the constant\\n constant = 1.0\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Calculate the utilization ratio of the current edge\\n utilization_ratio = edge_n_used[current_node, next_node] / total_permutations\\n \\n # Update the edge distance between the current and next node with the weight\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + constant / utilization_ratio\\n\\n # Update the edge distance between the next and current node with the weight\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + constant / utilization_ratio\\n \\n return updated_edge_distance\",\n \"objective\": 0.01277,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by considering the local optimal tour and the ratio of the number of times each edge is used to a parameter defined as the sum of the maximum edge distance multiplied by the number of edges, divided by the maximum utilization ratio of edges in the current tour.\\n\\nPython implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n # Create a copy of the edge distance matrix\\n updated_edge_distance = np.copy(edge_distance)\\n \\n # Get the number of nodes in the tour\\n num_nodes = len(local_opt_tour)\\n total_permutations = num_nodes * (num_nodes - 1)\\n \\n # Calculate the parameter\\n max_edge_distance = np.max(edge_distance)\\n max_utilization_ratio = np.max(edge_n_used / total_permutations)\\n param = (max_edge_distance * num_nodes) / max_utilization_ratio\\n \\n # Iterate over each node in the tour\\n for i in range(num_nodes):\\n # Get the current node ID and the next node ID\\n current_node = local_opt_tour[i]\\n next_node = local_opt_tour[(i + 1) % num_nodes] # Wrap around to the first node if at the last node\\n \\n # Update the edge distance between the current and next node\\n updated_edge_distance[current_node, next_node] = edge_distance[current_node, next_node] + param / edge_n_used[current_node, next_node]\\n\\n # Update the edge distance between the next and current node\\n updated_edge_distance[next_node, current_node] = edge_distance[next_node, current_node] + param / edge_n_used[next_node, current_node]\\n \\n return updated_edge_distance\",\n \"objective\": 0.01318,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += 0.1 * (max_n_used - edge_n_used[edge_i][edge_j])\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.04671,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to increase the distance for edges used more frequently in the tour and decrease the distance for edges used less frequently, while ensuring that the total distance remains the same.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n total_distance = np.sum(updated_edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n \\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n \\n avg_distance = total_distance / current_usage\\n updated_distance = current_distance + (avg_distance - current_distance) / current_usage\\n \\n updated_edge_distance[edge_index] = updated_distance\\n \\n return updated_edge_distance\",\n \"objective\": 0.07823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by increasing the distance of edges that were frequently used in the local optimal tour.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge_id = local_opt_tour[i], local_opt_tour[i+1]\\n updated_edge_distance[edge_id] += 1 / edge_n_used[edge_id]\\n return updated_edge_distance\",\n \"objective\": 0.45614,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by identifying the edges that were used in the local optimal tour and increasing their distances to discourage their usage in future permutations.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n edge_used = local_opt_tour[i:i+2]\\n edge_n_used[edge_used[0], edge_used[1]] += 1\\n edge_n_used[edge_used[1], edge_used[0]] += 1\\n updated_edge_distance[edge_used[0], edge_used[1]] += edge_n_used[edge_used[0], edge_used[1]]\\n updated_edge_distance[edge_used[1], edge_used[0]] += edge_n_used[edge_used[1], edge_used[0]]\\n return updated_edge_distance\",\n \"objective\": 0.86636,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by considering the edges used in the local optimal tour and reduces their distances to encourage exploration of alternative routes.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge_idx = int(edge_n_used[local_opt_tour[i], local_opt_tour[i+1]])\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] /= edge_idx\\n updated_edge_distance[local_opt_tour[i+1], local_opt_tour[i]] /= edge_idx\\n return updated_edge_distance\",\n \"objective\": 1.14706,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by identifying the edges in the local optimal tour and increasing their distances by a factor inversely proportional to their usage, so that they become less preferred in future iterations.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n for i in range(len(local_opt_tour)-1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n usage = edge_n_used[edge]\\n updated_edge_distance[edge] *= 1 / usage\\n \\n return updated_edge_distance\",\n \"objective\": 1.7979,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm aims to update the edge distance matrix based on the local optimal tour, by considering the edges used and modifying the distances to encourage exploration of new pathways.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge_used = local_opt_tour[i], local_opt_tour[i+1]\\n edge_n_used[edge_used] += 1\\n updated_edge_distance[edge_used] += (1 / edge_n_used[edge_used])\\n return updated_edge_distance\",\n \"objective\": 1.80185,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distance matrix by increasing the distance of the edges used in the local optimal tour to discourage their usage in future iterations and tries to encourage exploration by decreasing the distance of unused edges.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n updated_edge_distance[edge_index] += 1\\n \\n for i in range(len(edge_n_used)):\\n for j in range(len(edge_n_used[i])):\\n if edge_n_used[i][j] == 0:\\n updated_edge_distance[i][j] -= 1\\n \\n return updated_edge_distance\",\n \"objective\": 2.12173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix based on the local optimal tour by increasing the distance between pairs of nodes that are connected in the tour.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n node1 = local_opt_tour[i]\\n node2 = local_opt_tour[i+1]\\n updated_edge_distance[node1, node2] += 1\\n updated_edge_distance[node2, node1] += 1\\n return updated_edge_distance\",\n \"objective\": 2.54362,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\n The algorithm updates the edge distance matrix by identifying the edges that belong to the local optimal tour and increasing their distances, while decreasing the distances of the remaining edges that were not used in the tour, based on the number of times each edge was used during permutation.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n used_edges = np.zeros(edge_distance.shape)\\n \\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n \\n used_edges[start][end] += 1\\n used_edges[end][start] += 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if used_edges[i][j] > 0:\\n updated_edge_distance[i][j] += used_edges[i][j]\\n else:\\n updated_edge_distance[i][j] -= edge_n_used[i][j]\\n \\n return updated_edge_distance\",\n \"objective\": 2.59737,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix based on the local optimal tour by resetting the distance of the edges used in the tour to infinity.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge_index = edge_n_used[local_opt_tour[i], local_opt_tour[i+1]]\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] = np.inf\\n updated_edge_distance[local_opt_tour[i+1], local_opt_tour[i]] = np.inf\\n edge_n_used[local_opt_tour[i], local_opt_tour[i+1]] = np.inf\\n edge_n_used[local_opt_tour[i+1], local_opt_tour[i]] = np.inf\\n return updated_edge_distance\",\n \"objective\": 2.89268,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm identifies and removes the most frequently used edge in the local optimal tour from the edge distance matrix, and then recalculates the distances of those edges based on their adjacent edges.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n most_used_edge = np.argmax(edge_n_used)\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour) - 1):\\n edge = (local_opt_tour[i], local_opt_tour[i+1])\\n if edge[0] == most_used_edge or edge[1] == most_used_edge:\\n updated_edge_distance[edge[0], edge[1]] = np.inf\\n updated_edge_distance[edge[1], edge[0]] = np.inf\\n else:\\n adjacent_edges = np.unique(np.concatenate((local_opt_tour[:i], local_opt_tour[i+2:])))\\n updated_edge_distance[edge[0], edge[1]] = np.min(edge_distance[edge[0], adjacent_edges]) + np.min(edge_distance[adjacent_edges, edge[1]])\\n updated_edge_distance[edge[1], edge[0]] = np.min(edge_distance[edge[1], adjacent_edges]) + np.min(edge_distance[adjacent_edges, edge[0]])\\n \\n return updated_edge_distance\",\n \"objective\": 3.13655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by increasing the distances of the edges used in the local optimal tour to discourage their usage in future permutations.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n for i in range(len(local_opt_tour)-1):\\n updated_edge_distance[local_opt_tour[i], local_opt_tour[i+1]] += 1\\n updated_edge_distance[local_opt_tour[-1], local_opt_tour[0]] += 1\\n return updated_edge_distance\",\n \"objective\": 3.16507,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm will update the edge distance matrix based on the local optimal tour by identifying the edges that are used the most and increasing their distances in the matrix by a certain factor, in order to encourage exploration of other routes.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n factor = 1.2\\n \\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n updated_edge_distance[edge_index] *= factor\\n edge_n_used[edge_index] += 1\\n \\n return updated_edge_distance\",\n \"objective\": 3.23456,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm is to identify the edges in the local optimal tour that have been used the most, and increase the distance of those edges in the edge distance matrix by multiplying it with a factor greater than 1. This will make the algorithm explore alternative routes and avoid being trapped in the local optimum.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n max_edge_usage = np.max(edge_n_used)\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n if edge_n_used[local_opt_tour[i]][local_opt_tour[i+1]] == max_edge_usage:\\n updated_edge_distance[local_opt_tour[i]][local_opt_tour[i+1]] *= 1.2\\n \\n return updated_edge_distance\",\n \"objective\": 3.23752,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm updates the edge distance matrix based on the local optimal tour by increasing the distances of the edges used in the tour and decreasing the distances of the unused edges based on the number of times each edge is used.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance: np.ndarray, local_opt_tour: np.ndarray, edge_n_used: np.ndarray) -> np.ndarray:\\n updated_edge_distance = np.copy(edge_distance)\\n \\n for i in range(len(local_opt_tour)-1):\\n used_edge = local_opt_tour[i:i+2]\\n updated_edge_distance[used_edge[0]][used_edge[1]] += 1\\n \\n for i in range(updated_edge_distance.shape[0]):\\n for j in range(updated_edge_distance.shape[1]):\\n if i != j and updated_edge_distance[i][j] == 0:\\n updated_edge_distance[i][j] -= edge_n_used[i][j]\\n \\n return updated_edge_distance\",\n \"objective\": 3.30089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix based on the local optimal tour by increasing the distance of edges that are frequently used and decreasing the distance of edges that are rarely used.\",\n \"code\": \"import numpy as np\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n updated_edge_distance[local_opt_tour[i]][local_opt_tour[i+1]] *= 1 + (edge_n_used[local_opt_tour[i]][local_opt_tour[i+1]]/np.sum(edge_n_used))\\n return updated_edge_distance\",\n \"objective\": 3.45265,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm for updating the edge distance matrix involves identifying the edge with the highest usage count in the local optimal tour and increasing its distance in the edge distance matrix. \\nThe main steps are as follows: \\n1. Initialize a counter for each edge in the local optimal tour.\\n2. Iterate through the local optimal tour and increment the counter for each edge used.\\n3. Find the edge with the highest usage count.\\n4. Increase the distance of the identified edge in the edge distance matrix by a certain factor.\\n5. Return the updated edge distance matrix.\\n\\n\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n edge_usage_count = np.zeros_like(edge_n_used)\\n for i in range(len(local_opt_tour)-1):\\n edge_id = local_opt_tour[i:i+2]\\n edge_usage_count[edge_id[0], edge_id[1]] += 1\\n \\n highest_usage_edge = np.unravel_index(np.argmax(edge_usage_count), edge_usage_count.shape)\\n updated_edge_distance = edge_distance.copy()\\n updated_edge_distance[highest_usage_edge] += 0.1 * edge_distance[highest_usage_edge]\\n \\n return updated_edge_distance\",\n \"objective\": 3.47134,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the edge distance matrix by finding the edges used in the local optimum tour and increasing their distances to discourage their selection in future permutations.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge_id = local_opt_tour[i], local_opt_tour[i+1]\\n updated_edge_distance[edge_id] += edge_n_used[edge_id]\\n return updated_edge_distance\",\n \"objective\": 3.49348,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm performs a depth-first search by iteratively removing each edge in the local optimal tour and recalculating the new shortest tour without that edge, updating the edge distance matrix accordingly, until no improvement can be made anymore.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n n = len(edge_distance)\\n\\n for i in range(len(local_opt_tour)):\\n # Remove current edge from local optimal tour\\n source = local_opt_tour[i]\\n target = local_opt_tour[(i+1) % n]\\n\\n # Update edge distance matrix to infinity\\n updated_edge_distance[source][target] = np.inf\\n # Update edge usage count to 0\\n edge_n_used[source][target] -= 1\\n\\n # Iterate over all edges to find the new shortest tour\\n for j in range(n):\\n for k in range(n):\\n if j != k: # Avoid self-loops\\n # Calculate new potential tour distance\\n new_distance = edge_distance[j][k] + updated_edge_distance[k][source] + updated_edge_distance[target][j]\\n\\n # If the new distance is shorter, update the edge distance and usage count\\n if new_distance < updated_edge_distance[source][target]:\\n updated_edge_distance[source][target] = new_distance\\n edge_n_used[source][target] += 1\\n\\n # Reset the edge distance and usage count for the next iteration\\n updated_edge_distance[source][target] = edge_distance[source][target]\\n edge_n_used[source][target] += 1\\n\\n return updated_edge_distance\",\n \"objective\": 10000000000.0,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02561,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linearly decreasing function of the number of times each edge has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = (max_n_used - edge_n_used[edge_i][edge_j]) * 0.05 # new parameter setting\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.03499,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a logarithmically decreasing function of the number of times each edge has been used.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = np.log(max_n_used + 1) / (edge_n_used[edge_i][edge_j] + 1)\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.03641,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += 0.1 * (max_n_used - edge_n_used[edge_i][edge_j])\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.04671,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently with a modified score function that includes a weight factor for the edge usage and a decay factor. The weight factor and decay factor are set to 4 and 0.9 respectively.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n weight_factor = 4 # Define a different weight factor for edge usage\\n decay_factor = 0.9 # Define a different decay factor for distance modification\\n\\n updated_distance = current_distance - ((current_distance - total_distance / current_usage) / (current_usage * weight_factor)) * decay_factor\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.05397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently, while ensuring that the total distance remains the same.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n updated_distance = current_distance - (current_distance - total_distance / current_usage) / current_usage\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.07823,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently with a modified score function that includes a weight factor for the edge usage and a decay factor (with different parameter values).\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n weight_factor = 3 # Define a different weight factor for edge usage\\n decay_factor = 0.8 # Define a different decay factor for distance modification\\n\\n updated_distance = current_distance - ((current_distance - total_distance / current_usage) / (current_usage * weight_factor)) * decay_factor\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.08591,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently with a modified score function that includes a weight factor for the edge usage and a decay factor.\\n\\nPython code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n weight_factor = 2 # Define a weight factor for edge usage\\n decay_factor = 0.5 # Define a decay factor for distance modification\\n\\n updated_distance = current_distance - ((current_distance - total_distance / current_usage) / (current_usage * weight_factor)) * decay_factor\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.08733,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently, while ensuring that the total distance remains the same. The updated edge distances are calculated using a weighted average of the current distance and the total distance divided by the usage count, with a different score function that includes a penalty term based on the square root of the current usage count.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n # Updated score function with penalty term\\n updated_distance = current_distance - (current_distance - total_distance / (current_usage + 1) - np.sqrt(current_usage)) / (current_usage + 1)\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.08807,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm updates the edge distance matrix based on the local optimal tour and the number of times each edge is used, by increasing the distance for edges used more frequently and decreasing the distance for edges used less frequently, while keeping the total distance constant.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n updated_distance = current_distance + (total_distance - current_distance) / (current_usage + 1)\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.09316,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently, while ensuring that the total distance remains the same. The updated edge distances are calculated using a modified score function that takes into account the current distance, total distance, and usage count. \\n\\n\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n # New score function\\n updated_distance = current_distance - (current_distance - (total_distance / (current_usage + 1))) / ((current_usage + 1) ** 0.5)\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.09369,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by increasing the distances of the edges that belong to the local optimal tour and have not been used before, while decreasing the distances of the edges that were not used in the tour based on the number of times each edge was used during permutation. The scoring function is modified to weight the increase and decrease of the distances differently, with a higher weight assigned to the decrease of unused edges. Additionally, the weight for decreasing the distances of unused edges is increased to 0.9 to prioritize minimizing the distance.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n used_edges = np.zeros(edge_distance.shape)\\n\\n # Step 1: Update distances of edges belonging to the local optimal tour\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n\\n if used_edges[start][end] == 0:\\n updated_edge_distance[start][end] += 1\\n else:\\n updated_edge_distance[start][end] -= 1\\n\\n if used_edges[end][start] == 0:\\n updated_edge_distance[end][start] += 1\\n else:\\n updated_edge_distance[end][start] -= 1\\n\\n # Step 2: Update distances of edges not used in the tour\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if used_edges[i][j] > 0:\\n updated_edge_distance[i][j] += used_edges[i][j] * 0.5 # Increase distance with weight 0.5\\n else:\\n updated_edge_distance[i][j] -= edge_n_used[i][j] * 0.9 # Decrease distance with weight 0.9\\n\\n return updated_edge_distance\",\n \"objective\": 0.09401,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently, while ensuring that the total distance remains the same. The updated edge distances are calculated using a weighted average of the current distance and the total distance divided by the usage count, with a different score function.\\n\\nPython code:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n # Updated score function\\n updated_distance = current_distance - (current_distance - total_distance / (current_usage + 1)) / (current_usage + 1)\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.09457,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently with a modified score function that includes a weight factor for the edge usage.\\n\\nPython code:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n weight_factor = 2 # Define a weight factor for edge usage\\n\\n updated_distance = current_distance - (current_distance - total_distance / current_usage) / (current_usage * weight_factor)\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.10489,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by increasing the distances of the edges that belong to the local optimal tour and have not been used before, while decreasing the distances of the edges that were not used in the tour based on the number of times each edge was used during permutation. The scoring function is modified to weight the increase and decrease of the distances differently, with a higher weight assigned to the decrease of unused edges.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n used_edges = np.zeros(edge_distance.shape)\\n\\n # Step 1: Update distances of edges belonging to the local optimal tour\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n\\n if used_edges[start][end] == 0:\\n updated_edge_distance[start][end] += 1\\n else:\\n updated_edge_distance[start][end] -= 1\\n\\n if used_edges[end][start] == 0:\\n updated_edge_distance[end][start] += 1\\n else:\\n updated_edge_distance[end][start] -= 1\\n\\n # Step 2: Update distances of edges not used in the tour\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if used_edges[i][j] > 0:\\n updated_edge_distance[i][j] += used_edges[i][j] * 0.5 # Increase distance with weight 0.5\\n else:\\n updated_edge_distance[i][j] -= edge_n_used[i][j] * 0.8 # Decrease distance with weight 0.8\\n\\n return updated_edge_distance\",\n \"objective\": 0.11147,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: \\\"The new algorithm updates the edge distance matrix based on the local optimal tour by redistributing the edge distances to decrease the distance for edges used more frequently in the tour and increase the distance for edges used less frequently, while ensuring that the total distance remains the same. The updated edge distances are calculated using a weighted average of the current distance and the total distance divided by the usage count, with a different score function that includes a penalty term based on the square of the current usage count.\\\"\\n\\nPython code:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = edge_distance.copy()\\n\\n total_distance = np.sum(updated_edge_distance)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_index = local_opt_tour[i], local_opt_tour[i+1]\\n\\n current_distance = updated_edge_distance[edge_index]\\n current_usage = edge_n_used[edge_index]\\n\\n # Updated score function with penalty term\\n updated_distance = current_distance - (current_distance - total_distance / (current_usage + 1) - current_usage**2) / (current_usage + 1)\\n\\n updated_edge_distance[edge_index] = updated_distance\\n\\n return updated_edge_distance\",\n \"objective\": 0.11221,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by increasing the distances of the edges that belong to the local optimal tour and have not been used before, while decreasing the distances of the edges that were not used in the tour based on a weighted factor calculated by multiplying the number of times each edge was used during permutation with a constant weight factor.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n used_edges = np.zeros(edge_distance.shape)\\n weight_factor = 0.5 # Constant weight factor used to calculate weighted scores\\n \\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n \\n if used_edges[start][end] == 0:\\n updated_edge_distance[start][end] += 1\\n else:\\n updated_edge_distance[start][end] -= 1\\n \\n if used_edges[end][start] == 0:\\n updated_edge_distance[end][start] += 1\\n else:\\n updated_edge_distance[end][start] -= 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if used_edges[i][j] > 0:\\n updated_edge_distance[i][j] += used_edges[i][j]\\n else:\\n updated_edge_distance[i][j] -= edge_n_used[i][j] * weight_factor\\n \\n return updated_edge_distance\",\n \"objective\": 0.13206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by increasing the distances of the edges that belong to the local optimal tour and have not been used before, while decreasing the distances of the edges that were not used in the tour based on the number of times each edge was used during permutation. The scoring function is modified to weight the increase and decrease of the distances differently, with a higher weight assigned to the decrease of unused edges and a lower weight assigned to the increase of used edges.\\n\\nImplementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n used_edges = np.zeros(edge_distance.shape)\\n\\n # Step 1: Update distances of edges belonging to the local optimal tour\\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n\\n if used_edges[start][end] == 0:\\n updated_edge_distance[start][end] += 0.5 # Increase distance with weight 0.5\\n else:\\n updated_edge_distance[start][end] -= 0.8 # Decrease distance with weight 0.8\\n\\n if used_edges[end][start] == 0:\\n updated_edge_distance[end][start] += 0.5 # Increase distance with weight 0.5\\n else:\\n updated_edge_distance[end][start] -= 0.8 # Decrease distance with weight 0.8\\n\\n # Step 2: Update distances of edges not used in the tour\\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if used_edges[i][j] > 0:\\n updated_edge_distance[i][j] += used_edges[i][j] * 0.3 # Increase distance with weight 0.3\\n else:\\n updated_edge_distance[i][j] -= edge_n_used[i][j] * 0.5 # Decrease distance with weight 0.5\\n\\n return updated_edge_distance\",\n \"objective\": 0.15666,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by increasing the distances of the edges that belong to the local optimal tour and have not been used before, while decreasing the distances of the edges that were not used in the tour based on the number of times each edge was used during permutation.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n used_edges = np.zeros(edge_distance.shape)\\n \\n for i in range(len(local_opt_tour)-1):\\n start = local_opt_tour[i]\\n end = local_opt_tour[i+1]\\n \\n if used_edges[start][end] == 0:\\n updated_edge_distance[start][end] += 1\\n else:\\n updated_edge_distance[start][end] -= 1\\n \\n if used_edges[end][start] == 0:\\n updated_edge_distance[end][start] += 1\\n else:\\n updated_edge_distance[end][start] -= 1\\n \\n for i in range(edge_distance.shape[0]):\\n for j in range(edge_distance.shape[1]):\\n if used_edges[i][j] > 0:\\n updated_edge_distance[i][j] += used_edges[i][j]\\n else:\\n updated_edge_distance[i][j] -= edge_n_used[i][j]\\n \\n return updated_edge_distance\",\n \"objective\": 0.172,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The algorithm updates the edge distance matrix by increasing the distance of edges that were less frequently used in the local optimal tour, with the amount of increase being proportional to the square root of the inverse of the number of times the edge was used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n for i in range(len(local_opt_tour)-1):\\n edge_id = local_opt_tour[i], local_opt_tour[i+1]\\n updated_edge_distance[edge_id] += np.sqrt(1 / (1 + edge_n_used[edge_id]))\\n return updated_edge_distance\",\n \"objective\": 0.22205,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linear decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\n\\nThe new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.8, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.8)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linear decreasing function of the number of times each edge has been used, but with a higher penalty for edges that have been used more frequently.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += (penalty**2)\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.8.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.3 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 0.3 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01689,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.6 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nCode:\\n``` \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.6 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.5, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01846,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as the square of the difference between the maximum number of edge uses and the actual number of edge uses, multiplied by a constant factor.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used - edge_n_used)**2 * 1.5 # Update penalty factor with a constant factor\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.8.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.8 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01943,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_11.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.8, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.8)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linear decreasing function of the number of times each edge has been used, but with a higher penalty for edges that have been used more frequently.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += (penalty**2)\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.8.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.3 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 0.3 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01689,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.6 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nCode:\\n``` \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.6 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.95', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n \\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.95\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01827,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.5, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01846,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as the square of the difference between the maximum number of edge uses and the actual number of edge uses, multiplied by a constant factor.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used - edge_n_used)**2 * 1.5 # Update penalty factor with a constant factor\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01932,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_12.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.8, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.8)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linear decreasing function of the number of times each edge has been used, but with a higher penalty for edges that have been used more frequently.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += (penalty**2)\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.5 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\\n\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.3 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 0.3 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01689,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.8, while maintaining the original penalty factor of 0.6.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.6 * np.power(ratio, 0.8)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.6 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nCode:\\n``` \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.6 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.95', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n \\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.95\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01827,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the square root of the ratio of the maximum number of edge uses and the actual number of edge uses, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = np.sqrt(max_n_used / edge_n_used)\\n penalty_factor = 0.7 * ratio\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01846,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_13.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.8 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00756,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.8 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.7.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used) ** 1.7\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01146,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.8, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.8)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe new algorithm updates the edge distance matrix by penalizing edges based on the number of times they have been used during the permutation, with the penalty being calculated as the square of the difference between the maximum number of edge usage and the number of times the edge has been used.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.5 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\\n\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.3 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 0.3 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01689,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.8, while maintaining the original penalty factor of 0.6.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.6 * np.power(ratio, 0.8)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.6 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nCode:\\n``` \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.6 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01817,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_14.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.8 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00756,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used / edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used / edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.7.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**1.7\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01146,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.55 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.55 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.8, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.8)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe new algorithm updates the edge distance matrix by penalizing edges based on the number of times they have been used during the permutation, with the penalty being calculated as the square of the difference between the maximum number of edge usage and the number of times the edge has been used.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) raised to the power of 2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01659,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.3 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 0.3 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01689,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0173,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_15.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.8 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00756,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used / edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used / edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.7.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**1.7\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01146,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) instead of 0.55 * (max_n_used - edge_n_used) raised to the power of 1.5. \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.55 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.55 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.7 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe new algorithm updates the edge distance matrix by penalizing edges based on the number of times they have been used during the permutation, with the penalty being calculated as the square of the difference between the maximum number of edge usage and the number of times the edge has been used.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) raised to the power of 2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01659,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.3 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 0.3 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01689,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0173,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_16.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.8 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00756,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used / edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used / edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.7.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**1.7\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01146,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) instead of 0.55 * (max_n_used - edge_n_used) raised to the power of 1.5. \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.55 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.55 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.7 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe new algorithm updates the edge distance matrix by penalizing edges based on the number of times they have been used during the permutation, with the penalty being calculated as the square of the difference between the maximum number of edge usage and the number of times the edge has been used.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) raised to the power of 2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01659,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.3 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 0.3 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01689,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0173,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_17.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.8 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00756,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used / edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used / edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm penalizes edges based on the difference between the number of times they are used in the local optimal tour and the maximum number of times any edge is used in the entire tour.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] += penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.7.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**1.7\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01146,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) instead of 0.55 * (max_n_used - edge_n_used) raised to the power of 1.5. \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.55 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.55 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.7 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe new algorithm updates the edge distance matrix by penalizing edges based on the number of times they have been used during the permutation, with the penalty being calculated as the square of the difference between the maximum number of edge usage and the number of times the edge has been used.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.2 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.2 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01446,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.3 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.3 + 1.3 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01527,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.5 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 1.5 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01589,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_18.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.8 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00756,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used / edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used / edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm penalizes edges based on the difference between the number of times they are used in the local optimal tour and the maximum number of times any edge is used in the entire tour.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] += penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the penalty factor based on the frequency of edge uses in the local optimal tour, with a higher penalty for edges that have been used more often.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.0 + 0.2 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.7.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**1.7\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01146,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) instead of 0.55 * (max_n_used - edge_n_used) raised to the power of 1.5. \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.55 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.55 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.7 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe new algorithm updates the edge distance matrix by penalizing edges based on the number of times they have been used during the permutation, with the penalty being calculated as the square of the difference between the maximum number of edge usage and the number of times the edge has been used.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.2 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nNew algorithm implementation in Python:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.2 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01446,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.3 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.3 + 1.3 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01527,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.5 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 1.5 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01589,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_19.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.8 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.5 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00756,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used / edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used / edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00974,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm:\\nThe new algorithm penalizes edges based on the difference between the number of times they are used in the local optimal tour and the maximum number of times any edge is used in the entire tour.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] += penalty\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm adjusts the penalty factor based on the frequency of edge uses in the local optimal tour, with a higher penalty for edges that have been used more often.\\n\\nNew algorithm code:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.0 + 0.2 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01087,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.7.\\n\\nCode:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**1.7\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01146,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.35 * (max_n_used - edge_n_used) instead of 0.55 * (max_n_used - edge_n_used) raised to the power of 1.5. \\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01331,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.55 * (max_n_used - edge_n_used) instead of 0.65 * (max_n_used - edge_n_used) raised to the power of 1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.55 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.7 * (max_n_used / edge_n_used)**0.8.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * (max_n_used / edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01397,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: \\n\\nThe new algorithm updates the edge distance matrix by penalizing edges based on the number of times they have been used during the permutation, with the penalty being calculated as the square of the difference between the maximum number of edge usage and the number of times the edge has been used.\\n\\nUpdated code:\\n\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.2 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nNew algorithm implementation in Python:\\n```\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.2 + 0.8 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01446,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor based on the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is determined by a weighting factor of 0.6 added to the ratio of the difference to the maximum number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 0.6 + ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01509,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.3 multiplied by the ratio of the difference between the maximum number of edge uses and the actual number of edge uses, to the maximum number of edge uses.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = (max_n_used - edge_n_used) / max_n_used\\n penalty_factor = 1.3 + 1.3 * ratio\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01527,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 'penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8', where 'max_n_used' is the maximum number of edge uses and 'edge_n_used' is a matrix containing the number of each edge used during permutation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n\\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor determined by the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1 * (max_n_used - edge_n_used) ** 2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.power((max_n_used - edge_n_used), 1.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor determined by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.sqrt((max_n_used - edge_n_used))\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02088,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.75 * (max_n_used - edge_n_used) instead of 0.5 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.2 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a logarithmically decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = np.log(2 + max_n_used - edge_n_used[edge_i][edge_j]) # new parameter setting\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.6.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 1.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02247,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings): The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.75.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * np.square((max_n_used - edge_n_used))\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02561,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor based on the square root of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02571,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, using a different penalty factor calculation.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.exp(2*(max_n_used - edge_n_used))\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02656,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02676,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02781,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.3.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02846,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.05.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.05 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.03122,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a lower penalty factor of 0.4.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.4 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.03163,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a square root function of the number of times each edge has been used.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = np.sqrt(max_n_used + 1 - edge_n_used[edge_i][edge_j]) # new parameter setting\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.03201,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linearly decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor determined by the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1 * (max_n_used - edge_n_used) ** 2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.power((max_n_used - edge_n_used), 1.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used) raised to the power of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02088,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.75 * (max_n_used - edge_n_used) instead of 0.5 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.2 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a logarithmically decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = np.log(2 + max_n_used - edge_n_used[edge_i][edge_j]) # new parameter setting\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.6.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 1.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02247,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor determined by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02282,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings): The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.75.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * np.square((max_n_used - edge_n_used))\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0233,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02332,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nNew Algorithm Steps:\\n1. Create a copy of the edge distance matrix and assign it to \\\"updated_edge_distance\\\".\\n2. Find the maximum number of edge uses in the \\\"edge_n_used\\\" matrix and assign it to \\\"max_n_used\\\".\\n3. Calculate the penalty factor for each edge by subtracting the actual number of uses from \\\"max_n_used\\\" and raise it to a lower power, e.g., 0.8.\\n4. Iterate over the elements in the \\\"local_opt_tour\\\" array from index 0 to index len(local_opt_tour)-2 (excluding the last element).\\n - Assign the value at index \\\"i\\\" of \\\"local_opt_tour\\\" to \\\"edge_i\\\".\\n - Assign the value at index (i+1) of \\\"local_opt_tour\\\" to \\\"edge_j\\\".\\n - Update the edge distance in \\\"updated_edge_distance\\\" by adding the penalty factor for \\\"edge_i\\\" and \\\"edge_j\\\".\\n - Update the edge distance in \\\"updated_edge_distance\\\" by setting the distance at [edge_j][edge_i] to the same value as [edge_i][edge_j] (symmetrical matrix).\\n5. Return the updated edge distance matrix \\\"updated_edge_distance\\\".\\n\\nNew Algorithm in Python:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = np.power((max_n_used - edge_n_used), 0.8)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0246,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 0.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02533,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02561,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor based on the square root of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nNew algorithm implementation:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02571,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor determined by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.9.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.9 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02633,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm penalizes the distances of frequently used edges in the local optimal tour by multiplying the penalty factor with a lower power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linearly decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm:\\nThe new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on an exponentially decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = (max_n_used - edge_n_used[edge_i][edge_j])**2\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used) raised to the power of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by multiplying the distances of edges that have been frequently used in the local optimal tour by a penalty factor calculated as the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] *= penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02088,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.75 * (max_n_used - edge_n_used) instead of 0.5 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.2 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a logarithmically decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = np.log(2 + max_n_used - edge_n_used[edge_i][edge_j]) # new parameter setting\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.35 * (max_n_used - edge_n_used)**1.25.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used)**1.25\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.6.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\n\\nNew algorithm code:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 1.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02247,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.8 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02282,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description (with different parameter settings): The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.75.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * np.square((max_n_used - edge_n_used))\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0233,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm penalizes the distances of frequently used edges in the local optimal tour by multiplying the penalty factor with a lower power of the difference between the maximum number of edge uses and the actual number of edge uses.\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used) ** 1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linearly decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as (max_n_used-edge_n_used)**2, where max_n_used is the maximum number of edge uses and edge_n_used is the matrix containing the number of each edge used during permutation.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used-edge_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used) raised to the power of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by multiplying the distances of edges that have been frequently used in the local optimal tour by a penalty factor calculated as the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] *= penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as max_n_used * (1 - edge_n_used/max_n_used)**2.\\n\\nImplementaion:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = max_n_used * (1 - edge_n_used/max_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02061,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02088,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.75 * (max_n_used - edge_n_used) instead of 0.5 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.2 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a logarithmically decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = np.log(2 + max_n_used - edge_n_used[edge_i][edge_j]) # new parameter setting\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02184,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.35 * (max_n_used - edge_n_used)**1.25.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.35 * (max_n_used - edge_n_used)**1.25\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02203,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.6.\\n\\nCode:\\n\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02206,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used)**2.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**2.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02238,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linearly decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1.0 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.0.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2.0 + 1.0 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as (max_n_used-edge_n_used)**2, where max_n_used is the maximum number of edge uses and edge_n_used is the matrix containing the number of each edge used during permutation.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used-edge_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.8.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.8 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01943,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used) raised to the power of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by multiplying the distances of edges that have been frequently used in the local optimal tour by a penalty factor calculated as the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] *= penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as max_n_used * (1 - edge_n_used/max_n_used)**2.\\n\\nImplementaion:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = max_n_used * (1 - edge_n_used/max_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02061,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02088,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.75 * (max_n_used - edge_n_used) instead of 0.5 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.75 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02127,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.2 * np.power((max_n_used - edge_n_used), 3)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02143,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a logarithmically decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = np.log(2 + max_n_used - edge_n_used[edge_i][edge_j]) # new parameter setting\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02184,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linearly decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as (max_n_used-edge_n_used)**2, where max_n_used is the maximum number of edge uses and edge_n_used is the matrix containing the number of each edge used during permutation.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used-edge_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.8.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as the square of the difference between the maximum number of edge uses and the actual number of edge uses, multiplied by a constant factor.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used - edge_n_used)**2 * 1.5 # Update penalty factor with a constant factor\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.8.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.8 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01943,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used) raised to the power of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by multiplying the distances of edges that have been frequently used in the local optimal tour by a penalty factor calculated as the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] *= penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.power((max_n_used - edge_n_used), 8)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as max_n_used * (1 - edge_n_used/max_n_used)**2.\\n\\nImplementaion:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = max_n_used * (1 - edge_n_used/max_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02061,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02067,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02088,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linearly decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as (max_n_used-edge_n_used)**2, where max_n_used is the maximum number of edge uses and edge_n_used is the matrix containing the number of each edge used during permutation.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used-edge_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.8.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as the square of the difference between the maximum number of edge uses and the actual number of edge uses, multiplied by a constant factor.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used - edge_n_used)**2 * 1.5 # Update penalty factor with a constant factor\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.8.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.8 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01943,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used) raised to the power of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by multiplying the distances of edges that have been frequently used in the local optimal tour by a penalty factor calculated as the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] *= penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01989,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the ratio between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * ((max_n_used / edge_n_used) ** 2).\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * ((max_n_used / edge_n_used) ** 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.5.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * np.power((max_n_used - edge_n_used), 8)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02049,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as max_n_used * (1 - edge_n_used/max_n_used)**2.\\n\\nImplementaion:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = max_n_used * (1 - edge_n_used/max_n_used)**2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02061,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used)**1.2.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.02067,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob2_TSP_GLS/run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"The new algorithm penalizes the distances of frequently used edges in the local optimal tour using a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses, with a penalty factor of 0.6 * (max_n_used - edge_n_used) instead of 0.8 * (max_n_used - edge_n_used) raised to the power of 1.5.\",\n \"code\": \"def update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**1.2\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.00712,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linear decreasing function of the number of times each edge has been used.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01073,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. However, it uses a different penalty factor of 0.65 * (max_n_used - edge_n_used) instead of 0.75 * (max_n_used - edge_n_used) raised to the power of 1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.65 * (max_n_used - edge_n_used) ** 1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01089,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.6.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.6\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01256,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 2.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 2 + 1 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01278,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.6 * (max_n_used - edge_n_used)**0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.6 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01346,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the square root of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.2.\\n\\nCode:\\n\\n``` \",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.2 * np.sqrt(max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01384,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour based on a linear decreasing function of the number of times each edge has been used, but with a higher penalty for edges that have been used more frequently.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n\\n penalty = max_n_used - edge_n_used[edge_i][edge_j]\\n \\n updated_edge_distance[edge_i][edge_j] += (penalty**2)\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01424,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.5 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.5.\\n\\nCode:\\n``` \\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.5 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01559,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.8 * (max_n_used - edge_n_used)**0.8.\\n\\nUpdated Code:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.5 * (max_n_used - edge_n_used)**1.5.\\n\\nCode:\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.5 * (max_n_used - edge_n_used)**1.5\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01655,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.7.\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.7 * np.power((max_n_used - edge_n_used), 4)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01762,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses, but with a reduced penalty factor of 0.1.\\n\\nCode:\\n```\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.1 * np.power((max_n_used - edge_n_used), 4)\\n\\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01776,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by the logarithm of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.log(max_n_used - edge_n_used + 1)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.0178,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 0.6 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses.\\n\\nCode:\\n``` \\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.5 + 0.6 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01817,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\nThe new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour with a penalty factor multiplied by the ratio of the maximum number of edge uses and the actual number of edge uses raised to the power of 0.5, while maintaining the original penalty factor of 0.7.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n ratio = max_n_used / edge_n_used\\n penalty_factor = 0.7 * np.power(ratio, 0.5)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01846,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm penalizes the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a higher power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as the square of the difference between the maximum number of edge uses and the actual number of edge uses, multiplied by a constant factor.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = (max_n_used - edge_n_used)**2 * 1.5 # Update penalty factor with a constant factor\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01932,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by adding a penalty to the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a constant value of 1 multiplied by the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 1.8.\\n\\nCode:\\n``` \\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 1.8 * (max_n_used - edge_n_used)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01943,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by penalizing the distances of edges that have been frequently used in the local optimal tour, with a penalty factor increased by a lower power of the difference between the maximum number of edge uses and the actual number of edge uses. The penalty factor is defined as 0.3 * (max_n_used - edge_n_used) raised to the power of 0.8.\\n\\nCode:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.3 * (max_n_used - edge_n_used)**0.8\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] += penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01988,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New Algorithm Description: The new algorithm updates the edge distance matrix by multiplying the distances of edges that have been frequently used in the local optimal tour by a penalty factor calculated as the square of the difference between the maximum number of edge uses and the actual number of edge uses, but with a higher penalty factor of 0.8.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef update_edge_distance(edge_distance, local_opt_tour, edge_n_used):\\n updated_edge_distance = np.copy(edge_distance)\\n max_n_used = np.max(edge_n_used)\\n penalty_factor = 0.8 * np.power((max_n_used - edge_n_used), 2)\\n \\n for i in range(len(local_opt_tour)-1):\\n edge_i = local_opt_tour[i]\\n edge_j = local_opt_tour[i+1]\\n \\n updated_edge_distance[edge_i][edge_j] *= penalty_factor[edge_i][edge_j]\\n updated_edge_distance[edge_j][edge_i] = updated_edge_distance[edge_i][edge_j] # symmetrical matrix\\n \\n return updated_edge_distance\",\n \"objective\": 0.01989,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm idea is to update the execution time matrix based on the current sequence of jobs and then select the top jobs to perturb in order to avoid being trapped in local optimum scheduling and minimize the makespan. The main steps include updating the execution time matrix based on the current job sequence and then selecting the top jobs to perturb based on their impact on the scheduling makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Update execution time matrix\\n new_matrix = time_matrix.copy()\\n for i in range(n):\\n for j in range(m):\\n new_matrix[i][j] *= (n - np.where(current_sequence == i)[0][0])\\n\\n # Select top jobs to perturb\\n makespan = np.max(np.sum(new_matrix, axis=1))\\n job_impact = np.sum(new_matrix, axis=1) - makespan\\n perturb_jobs = np.argsort(job_impact)[-m:]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 10000000000.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm selects the top jobs based on their execution time on different machines, then perturbs the selected jobs in the current sequence to update the execution time matrix. First, it computes the average execution time of each job across all machines and selects the top jobs with the highest average execution time. Then, it randomly perturbs the selected jobs in the current sequence, updating the execution time matrix accordingly.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.60938,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the total execution time for each job in the current sequence, update the time matrix by increasing the execution time of the top jobs, and select the top jobs with the longest execution time to be perturbed for minimizing makespan.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = total_execution_time.argsort()[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n machine = np.argmin(np.sum(new_matrix, axis=0))\\n new_matrix[job][machine] += 1\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = total_execution_time.argsort()[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n machine = np.argmin(np.sum(new_matrix, axis=0))\\n new_matrix[job][machine] += 1\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3214.09375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the makespan for each job by adding its execution time on each machine, then sort the jobs based on their makespan. After that, we update the time matrix by perturbing the execution time of the top jobs in the sequence. Finally, we select the top perturbed jobs as the ones with the highest makespan to avoid local optimum scheduling.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix, axis=1)\\n sorted_jobs = np.argsort(makespan)\\n new_matrix = time_matrix.copy()\\n perturb_jobs = sorted_jobs[-m:]\\n \\n for job in perturb_jobs:\\n new_matrix[job] += np.random.rand(m) # Perturb execution time\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix, axis=1)\\n sorted_jobs = np.argsort(makespan)\\n new_matrix = time_matrix.copy()\\n perturb_jobs = sorted_jobs[-m:]\\n \\n for job in perturb_jobs:\\n new_matrix[job] += np.random.rand(m) # Perturb execution time\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3218.98438,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\n The algorithm first calculates the makespan for the current sequence using the time matrix. Then, it identifies the top jobs that contribute most to the makespan and selects them for perturbation to avoid local optima.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(job_contributions)[::-1][:min(5, n)]\\n \\n # Update time matrix (example of random perturbation)\\n new_matrix = time_matrix\\n for job in perturb_jobs:\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(job_contributions)[::-1][:min(5, n)]\\n \\n # Update time matrix (example of random perturbation)\\n new_matrix = time_matrix\\n for job in perturb_jobs:\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3174.32812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the completion time for each job on each machine based on the current time matrix.\\n2. Select the top jobs with the highest completion time on any machine to perturb.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n completion_time = np.zeros((n, m))\\n for i in range(n):\\n for j in range(m):\\n if j == 0:\\n completion_time[i][j] = time_matrix[current_sequence[i]][j]\\n else:\\n completion_time[i][j] = max(completion_time[i][j-1], completion_time[i][j-1]) + time_matrix[current_sequence[i]][j]\\n \\n total_completion_time = np.sum(completion_time, axis=1)\\n perturb_jobs = total_completion_time.argsort()[-m:]\\n\\n new_matrix = time_matrix.copy()\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3218.45312,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm initializes an empty list perturb_jobs and updates the time matrix by iterating through each job in the current_sequence and randomly selecting the execution time of the job on a different machine. It then calculates the makespan for each updated matrix and selects the top jobs from the current_sequence with the highest makespan to be perturbed.\\n}\\n```python\\nimport numpy as np\\nimport random\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = []\\n new_matrix = time_matrix.copy()\\n for job in current_sequence:\\n new_machine = random.choice([x for x in range(m) if x != job])\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n makespan = np.max(np.sum(new_matrix, axis=0))\\n perturb_jobs.append((job, makespan))\\n \\n perturb_jobs.sort(key=lambda x: x[1], reverse=True)\\n perturb_jobs = [x[0] for x in perturb_jobs][:m]\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = []\\n new_matrix = time_matrix.copy()\\n for job in current_sequence:\\n new_machine = random.choice([x for x in range(m) if x != job])\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n makespan = np.max(np.sum(new_matrix, axis=0))\\n perturb_jobs.append((job, makespan))\\n \\n perturb_jobs.sort(key=lambda x: x[1], reverse=True)\\n perturb_jobs = [x[0] for x in perturb_jobs][:m]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3193.14062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\n- First, calculate the makespan for each job by considering the total execution time of all jobs on each machine in the current sequence.\\n- Next, select the top jobs with the highest makespan and update the execution time matrix accordingly, and return the updated matrix and the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=0)\\n perturb_jobs = np.argsort(makespan)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3165.92188,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the new execution time matrix based on the current sequence of jobs and then select the top jobs to perturb based on the maximum difference in execution times across machines. First, calculate the execution time for each job on each machine according to the current sequence, then update the time matrix. Next, calculate the difference in execution times across machines for each job and select the top ones as perturb_jobs.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = np.zeros((n, m))\\n for i in range(n):\\n for j in range(m):\\n new_matrix[i][j] = time_matrix[current_sequence[i]][j]\\n \\n differences = np.max(new_matrix, axis=1) - np.min(new_matrix, axis=1)\\n perturb_jobs = np.argsort(differences)[::-1][:min(3, n)]\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = np.zeros((n, m))\\n for i in range(n):\\n for j in range(m):\\n new_matrix[i][j] = time_matrix[current_sequence[i]][j]\\n \\n differences = np.max(new_matrix, axis=1) - np.min(new_matrix, axis=1)\\n perturb_jobs = np.argsort(differences)[::-1][:min(3, n)]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3196.64062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the makespan for each job by updating the execution time matrix based on the current sequence, then select the top jobs with the highest makespan to perturb and avoid local optimum scheduling. \\nFirst, calculate the makespan for each job using the current sequence and time matrix. Then, select the top jobs with the highest makespan to perturb. Update the execution time matrix for the selected jobs, and return the new matrix and the perturb jobs list.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n current_makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)\\n perturb_jobs = current_makespan.argsort()[-min(2, n):]\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] += 1\\n return new_matrix, perturb_jobs\",\n \"objective\": 3208.95312,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe modified algorithm first calculates the makespan for the current sequence using the time matrix. Then, it identifies the top jobs that contribute most to the makespan and selects them for perturbation with a probability inversely proportional to their contribution to the makespan.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_prob = 1 - (job_contributions / np.sum(job_contributions)) # Probability inversely proportional to job contribution\\n perturb_jobs = np.random.choice(np.arange(n), size=min(5, n), replace=False, p=perturb_prob / np.sum(perturb_prob))\\n \\n # Update time matrix (example of perturbation: swap execution times of top jobs on a random machine)\\n new_matrix = time_matrix\\n for job in perturb_jobs:\\n machine = np.random.randint(0, m)\\n new_matrix[job][machine], new_matrix[job][np.argmin(new_matrix[job])] = new_matrix[job][np.argmin(new_matrix[job])], new_matrix[job][machine]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.85938,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix and select the top jobs with the highest makespan in order to perturb them to avoid local optimum scheduling and minimize the makespan. The main steps include calculating the makespan for each job based on the total execution time on each machine in the current sequence, selecting the top jobs with the highest makespan, updating the execution time matrix based on the selected jobs by adding a random perturbation, and returning the updated matrix and the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=1) # Calculate makespan for each job\\n perturb_jobs = np.argsort(makespan)[-m:] # Select top jobs with highest makespan\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.uniform(0.9, 1.1, size=new_matrix.shape[1]) # Generate random perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3162.21875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the makespan for the current sequence using the time matrix. Then, it identifies the top jobs that contribute most to the makespan and selects them for perturbation to avoid local optima.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(job_contributions)[::-1][:min(5, n)]\\n \\n # Update time matrix (example of perturbation: swap execution times of top jobs on a random machine)\\n new_matrix = time_matrix\\n for job in perturb_jobs:\\n machine = np.random.randint(0, m)\\n new_matrix[job][machine], new_matrix[job][np.argmin(new_matrix[job])] = new_matrix[job][np.argmin(new_matrix[job])], new_matrix[job][machine]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3162.40625,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm calculates the total time taken for each job across all machines and identifies the top jobs with the highest total time. It then randomly perturbs the execution time of these top jobs on all machines to avoid local optima and returns the updated time matrix and the perturbed jobs.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-min(4, n):]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.32812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm selects the top jobs based on their execution time on different machines, then perturbs the selected jobs in the current sequence to update the execution time matrix. First, it computes the average execution time of each job across all machines and selects the top jobs with the highest average execution time. Then, it randomly perturbs the selected jobs in the current sequence, updating the execution time matrix accordingly.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.60938,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\n\\nThe modified algorithm aims to update the execution time matrix and select the top jobs with the highest makespan in order to perturb them to avoid local optimum scheduling and minimize the makespan. The main steps include calculating the makespan for each job based on the total execution time on each machine in the current sequence, selecting the top jobs with the highest makespan, updating the execution time matrix based on the selected jobs, and returning the updated matrix and the perturbed jobs.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=1) # Calculate makespan for each job\\n perturb_jobs = np.argsort(makespan)[-m:] # Select top jobs with highest makespan\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n new_matrix[job] *= np.random.uniform(0.9, 1.1) # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3164.32812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the top jobs with the highest makespan, calculate their individual execution time on each machine, and update the time matrix by perturbing the execution time for the selected jobs. To achieve this, first, calculate the makespan for each job by considering the total execution time of all jobs on each machine in the current sequence. Then, select the top jobs with the highest makespan, calculate their execution time on each machine, update the time matrix accordingly, and return the updated matrix and the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(makespan)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3165.20312,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\n- First, calculate the makespan for each job by considering the total execution time of all jobs on each machine in the current sequence.\\n- Next, select the top jobs with the highest makespan and update the execution time matrix accordingly, and return the updated matrix and the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=0)\\n perturb_jobs = np.argsort(makespan)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3165.92188,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\n- First, calculate the makespan for each job by considering the total execution time of all jobs on each machine in the current sequence.\\n- Next, select the top jobs with the highest makespan and update the execution time matrix by scaling the execution times of the selected jobs with a random factor from a uniform distribution.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(makespan)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n scale_factor = np.random.uniform(0.9, 1.1)\\n new_matrix[job] = new_matrix[job] * scale_factor\\n return new_matrix, perturb_jobs\",\n \"objective\": 3166.75,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the idle time for each machine based on the current sequence and time matrix. Then, it identifies the top jobs that cause the highest idle time for each machine and selects them for perturbation to avoid local optima.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n idle_time = np.max(np.cumsum(time_matrix[current_sequence], axis=0), axis=0) - np.sum(time_matrix[current_sequence], axis=0)\\n perturb_jobs = np.argsort(idle_time)[::-1][:min(3, n)]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n return new_matrix, perturb_jobs\",\n \"objective\": 3169.0,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nThe modified algorithm will first calculate the completion time of each job on the most delayed machines and identify the top delayed jobs based on the difference between their completion time and the expected completion time. It will then apply perturbations to the execution time of the selected jobs on all machines and return the resulting matrix with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m]\\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.85938,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm will first identify the top delayed jobs based on their completion time compared to the expected completion time on the most delayed machines. It will then apply perturbations to the execution time of the selected jobs on all machines and return the resulting matrix with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.07812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines by considering the current job sequence, then selecting the top jobs from these machines for perturbation using a new technique to minimize the makespan. The main steps include evaluating machine utilization based on the current job sequence, selecting top jobs from underutilized machines, applying the new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_utilization = np.zeros(m)\\n for i, job in enumerate(current_sequence):\\n machine_utilization += time_matrix[job]\\n\\n underutilized_machines = np.argsort(machine_utilization)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.46875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines based on the current sequence, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines based on current sequence\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines based on current sequence\\n top_jobs = []\\n for machine in underutilized_machines:\\n job_sequence = np.argsort(time_matrix[:, machine])\\n for job in job_sequence:\\n if job in current_sequence:\\n top_jobs.append(job)\\n break\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.60938,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines in the scheduling, select the top jobs from these machines, and apply a new perturbation technique to balance the load and minimize the makespan. The main steps include identifying the underutilized machines, selecting the top jobs from these machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.76562,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines, select the top jobs from these machines to perturb, apply a new perturbation technique to the selected jobs based on the current job sequence, and return the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines based on the current job sequence, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmax([time_matrix[job, machine] for job in current_sequence])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.79688,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n \\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.8125,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the critical paths in the scheduling to improve the overall makespan. The main steps include identifying the critical paths based on the execution time matrix, selecting the top jobs from the critical paths, applying a novel perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify critical paths\\n critical_paths = np.argmax(time_matrix, axis=1)\\n\\n # Select top jobs from critical paths\\n top_jobs = np.unique(critical_paths, return_counts=True)\\n perturb_jobs = top_jobs[0][np.argsort(-top_jobs[1])[:m]]\\n\\n # Apply novel perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm first calculates the makespan for the current sequence using the time matrix. It then identifies the top jobs that contribute most to the makespan and selects them for perturbation with a probability inversely proportional to their contribution to the makespan. Afterward, it updates the time matrix by perturbing the execution times of the selected top jobs on randomly chosen machines.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_prob = 1 - (job_contributions / np.sum(job_contributions)) # Probability inversely proportional to job contribution\\n perturb_jobs = np.random.choice(np.arange(n), size=min(5, n), replace=False, p=perturb_prob / np.sum(perturb_prob))\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n machine = np.random.randint(0, m)\\n new_matrix[job][machine], new_matrix[job][np.argmin(new_matrix[job])] = new_matrix[job][np.argmin(new_matrix[job])], new_matrix[job][machine]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.34375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm will calculate the makespan for the current sequence using the time matrix. Then, it will select the top jobs that contribute most to the makespan for perturbation with a probability inversely proportional to their contribution. The function will then update the time matrix by swapping the execution times of the selected jobs on a random machine and return the updated time matrix along with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_prob = 1 - (job_contributions / np.sum(job_contributions)) # Probability inversely proportional to job contribution\\n perturb_jobs = np.random.choice(np.arange(n), size=min(5, n), replace=False, p=perturb_prob / np.sum(perturb_prob))\\n \\n # Update time matrix (example of perturbation: swap execution times of top jobs on a random machine)\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n machine = np.random.randint(0, m)\\n new_matrix[job][machine], new_matrix[job][np.argmin(new_matrix[job])] = new_matrix[job][np.argmin(new_matrix[job])], new_matrix[job][machine]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm first calculates the makespan for the current sequence using the time matrix. Then, it identifies the top jobs that contribute most to the makespan and selects them for perturbation with a probability inversely proportional to their contribution to the makespan.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_prob = 1 - (job_contributions / np.sum(job_contributions)) # Probability inversely proportional to job contribution\\n perturb_jobs = np.random.choice(np.arange(n), size=min(5, n), replace=False, p=perturb_prob / np.sum(perturb_prob))\\n \\n # Update time matrix (example of perturbation: swap execution times of top jobs on a random machine)\\n new_matrix = time_matrix\\n for job in perturb_jobs:\\n machine = np.random.randint(0, m)\\n new_matrix[job][machine], new_matrix[job][np.argmin(new_matrix[job])] = new_matrix[job][np.argmin(new_matrix[job])], new_matrix[job][machine]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.85938,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\nThe new algorithm will first calculate the total processing time for each job across all machines. Then, it will select the top jobs based on the total processing time and update the execution time matrix by randomly perturbing the selected jobs, aiming to diversify the search and minimize makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_processing_time = np.sum(time_matrix, axis=1) # Calculate total processing time for each job\\n perturb_jobs = np.argsort(total_processing_time)[-m:] # Select top jobs with highest total processing time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.uniform(0.9, 1.1, size=new_matrix.shape[1]) # Generate random perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.04688,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix and select the top jobs with the highest makespan in order to perturb them to avoid local optimum scheduling and minimize the makespan. The main steps include calculating the makespan for each job based on the total execution time on each machine in the current sequence, selecting the top jobs with the highest makespan, updating the execution time matrix based on the selected jobs by adding a random perturbation, and returning the updated matrix and the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=1) # Calculate makespan for each job\\n perturb_jobs = np.argsort(-makespan)[:m] # Select top jobs with highest makespan\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.uniform(0.9, 1.1, size=new_matrix.shape[1]) # Generate random perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.17188,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\nThe modified algorithm will calculate the weighted total processing time for each job across all machines using the current sequence. Then, it will select the top jobs based on the weighted total processing time and update the execution time matrix by randomly perturbing the selected jobs, aiming to diversify the search and minimize makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n weighted_processing_time = np.zeros(n) # Initialize array to store weighted total processing time for each job\\n for i, job in enumerate(current_sequence): # Iterate through the current sequence\\n weighted_processing_time[job] += np.sum(time_matrix[i]) # Calculate the weighted total processing time for each job\\n \\n perturb_jobs = np.argsort(weighted_processing_time)[-m:] # Select top jobs with highest weighted total processing time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.uniform(0.9, 1.1, size=new_matrix.shape[1]) # Generate random perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3160.39062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nBased on the concept of minimizing makespan, the algorithm will first calculate the average execution time for each job on all machines. Then, it will select the top jobs with the highest average execution time and update the execution time matrix by applying a random perturbation to the selected jobs, aiming to avoid local optimum scheduling and minimize makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix, axis=1) # Calculate average execution time for each job\\n perturb_jobs = np.argsort(avg_execution_time)[-m:] # Select top jobs with highest average execution time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.uniform(0.9, 1.1, size=new_matrix.shape[1]) # Generate random perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3160.5625,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the slack time for each job on all machines, then select the top jobs with the highest slack time and update the execution time matrix by applying a random perturbation to the selected jobs in order to minimize makespan and avoid local optimum scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n slack_time = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1) # Calculate slack time for each job\\n perturb_jobs = np.argsort(slack_time)[-m:] # Select top jobs with highest slack time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.uniform(0.9, 1.1, size=new_matrix.shape[1]) # Generate random perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3161.25,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description:\\nThe modified algorithm will calculate the average execution time on each machine for all jobs. It will then select the top jobs with the highest average execution time and update the execution time matrix by applying a random perturbation to the selected jobs, aiming to minimize makespan and avoid local optimum scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix, axis=0) # Calculate the average execution time on each machine for all jobs\\n perturb_jobs = np.argsort(avg_execution_time)[-m:] # Select the top jobs with the highest average execution time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.uniform(0.9, 1.1, size=new_matrix.shape[1]) # Generate random perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3161.53125,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n perturb_jobs = np.unique(delayed_jobs)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThe novel algorithm will first calculate the total processing time for each job across all machines based on the current sequence. Then, it will select the top jobs with the highest total processing time and update the execution time matrix by applying a different perturbation strategy to the selected jobs, aiming to further diversifying the search and minimize makespan.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_processing_time = np.zeros(n) # Initialize array to store total processing time for each job\\n for i, job in enumerate(current_sequence): # Iterate through the current sequence\\n total_processing_time[job] += np.sum(time_matrix[i]) # Calculate the total processing time for each job\\n \\n perturb_jobs = np.argsort(total_processing_time)[-m:] # Select top jobs with highest total processing time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1]) # Generate different perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.54688,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the bottleneck machines in the scheduling to improve the overall makespan. The main steps include identifying the bottleneck machines based on the execution time matrix, selecting the top jobs from the bottleneck machines, applying a novel perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify bottleneck machines\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n # Select top jobs from bottleneck machines\\n top_jobs = []\\n for machine in bottleneck_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply novel perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the bottleneck machines in the scheduling to improve the overall makespan. The main steps include identifying the bottleneck machines based on the execution time matrix, selecting the top jobs from the bottleneck machines, applying a novel perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = []\\n for machine in bottleneck_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the bottleneck machines in the scheduling to improve the overall makespan. The main steps include identifying the bottleneck machines based on the execution time matrix, selecting the top jobs from the bottleneck machines, applying a novel perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify bottleneck machines\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n # Select top jobs from bottleneck machines\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply novel perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.0625,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to update the execution time matrix and select the top jobs with the highest total processing time, to perturb them in order to minimize makespan and avoid local optimum scheduling. The main steps include calculating the total processing time for each job, selecting the top jobs with the highest total processing time, updating the execution time matrix based on the selected jobs by applying a perturbation strategy, and returning the updated matrix and the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_processing_time = np.sum(time_matrix, axis=1) # Calculate total processing time for each job\\n perturb_jobs = np.argsort(total_processing_time)[-m:] # Select top jobs with highest total processing time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1]) # Generate different perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the critical paths in the scheduling to improve the overall makespan. The main steps include identifying the critical paths based on the execution time matrix, selecting the top jobs from the critical paths, applying a novel perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify critical paths\\n critical_paths = np.argmax(time_matrix, axis=1)\\n\\n # Select top jobs from critical paths\\n top_jobs = np.unique(critical_paths, return_counts=True)\\n perturb_jobs = top_jobs[0][np.argsort(-top_jobs[1])[:m]]\\n\\n # Apply novel perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm first calculates the makespan for the current sequence using the time matrix. It then identifies the top jobs that contribute most to the makespan and selects them for perturbation with a probability inversely proportional to their contribution to the makespan. Afterward, it updates the time matrix by perturbing the execution times of the selected top jobs on randomly chosen machines.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_prob = 1 - (job_contributions / np.sum(job_contributions)) # Probability inversely proportional to job contribution\\n perturb_jobs = np.random.choice(np.arange(n), size=min(5, n), replace=False, p=perturb_prob / np.sum(perturb_prob))\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n machine = np.random.randint(0, m)\\n new_matrix[job][machine], new_matrix[job][np.argmin(new_matrix[job])] = new_matrix[job][np.argmin(new_matrix[job])], new_matrix[job][machine]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.34375,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n \\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to identify the machines with the largest difference in execution time between the most and least time-consuming jobs, and select the top jobs from these machines to perturb. The perturbation will be applied to the selected jobs on all machines to update the time matrix and improve the scheduling, with the final goal of minimizing makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_times = np.max(time_matrix, axis=0)\\n min_execution_times = np.min(time_matrix, axis=0)\\n time_difference = max_execution_times - min_execution_times\\n delayed_machines = np.argsort(time_difference)[::-1][:m]\\n \\n top_jobs = []\\n for machine in delayed_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.84375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n perturb_jobs = np.unique(delayed_jobs)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to select the most delayed jobs by comparing their actual completion time with the expected completion time on the most delayed machines. Next, perturbations are applied to the execution time of the selected jobs on all machines, and the resulting matrix is returned with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m]\\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.23438,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines and select the top jobs from these machines to perturb. It then applies a new perturbation technique to the selected jobs, resulting in an updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.26562,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"Algorithm description: \\nThe novel algorithm will first calculate the total processing time for each job across all machines based on the current sequence. Then, it will select the top jobs with the highest total processing time and update the execution time matrix by applying a different perturbation strategy to the selected jobs, aiming to further diversifying the search and minimize makespan.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_processing_time = np.zeros(n) # Initialize array to store total processing time for each job\\n for i, job in enumerate(current_sequence): # Iterate through the current sequence\\n total_processing_time[job] += np.sum(time_matrix[i]) # Calculate the total processing time for each job\\n \\n perturb_jobs = np.argsort(total_processing_time)[-m:] # Select top jobs with highest total processing time\\n new_matrix = time_matrix.copy() # Create a copy of the original time matrix\\n for job in perturb_jobs: # Iterate through the perturb jobs\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1]) # Generate different perturbation for each machine\\n new_matrix[job] *= perturbation # Update the execution time of perturb jobs\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.54688,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the bottleneck machines in the scheduling to improve the overall makespan. The main steps include identifying the bottleneck machines based on the execution time matrix, selecting the top jobs from the bottleneck machines, applying a novel perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify bottleneck machines\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n # Select top jobs from bottleneck machines\\n top_jobs = []\\n for machine in bottleneck_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply novel perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed machines based on the difference between the actual and expected completion time of jobs and select the top jobs from these machines to perturb, using a normal distribution perturbation. The perturbation will be applied to the execution time of the selected jobs on all machines to update the time matrix and improve the scheduling, with the final goal of minimizing makespan.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(delay_difference)[::-1][:m]\\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.9375,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines in the scheduling, select the top jobs from these machines, and apply a new perturbation technique to balance the load and minimize the makespan. The main steps include identifying the underutilized machines, selecting the top jobs from these machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.76562,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n \\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to identify the machines with the largest difference in execution time between the most and least time-consuming jobs, and select the top jobs from these machines to perturb. The perturbation will be applied to the selected jobs on all machines to update the time matrix and improve the scheduling, with the final goal of minimizing makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_times = np.max(time_matrix, axis=0)\\n min_execution_times = np.min(time_matrix, axis=0)\\n time_difference = max_execution_times - min_execution_times\\n delayed_machines = np.argsort(time_difference)[::-1][:m]\\n \\n top_jobs = []\\n for machine in delayed_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.84375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n perturb_jobs = np.unique(delayed_jobs)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed jobs by comparing their actual completion time with the expected completion time on the most delayed machines. Next, perturbations are applied to the execution time of the selected jobs on all machines, and the resulting matrix is returned with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.89062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n \\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to update the execution time matrix by calculating the machine load balance, selecting the top jobs from the underloaded machines, and perturbing these top jobs using a different perturbation technique to avoid local optimum scheduling and minimize makespan.\\n\\nThe main steps involve calculating the machine load balance, identifying underloaded machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_load_balance = np.std(time_matrix, axis=0)\\n underloaded_machines = np.argsort(machine_load_balance)[:m]\\n \\n top_jobs = []\\n for machine in underloaded_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.0625,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines in the scheduling, select the top jobs from these machines, and apply a new perturbation technique to balance the load and minimize the makespan. The main steps include identifying the underutilized machines, selecting the top jobs from these machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.76562,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n \\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to identify the machines with the largest difference in execution time between the most and least time-consuming jobs, and select the top jobs from these machines to perturb. The perturbation will be applied to the selected jobs on all machines to update the time matrix and improve the scheduling, with the final goal of minimizing makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_times = np.max(time_matrix, axis=0)\\n min_execution_times = np.min(time_matrix, axis=0)\\n time_difference = max_execution_times - min_execution_times\\n delayed_machines = np.argsort(time_difference)[::-1][:m]\\n \\n top_jobs = []\\n for machine in delayed_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.84375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n perturb_jobs = np.unique(delayed_jobs)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed jobs by comparing their actual completion time with the expected completion time on the most delayed machines. Next, perturbations are applied to the execution time of the selected jobs on all machines, and the resulting matrix is returned with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.89062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n \\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to update the execution time matrix by calculating the machine load balance, selecting the top jobs from the underloaded machines, and perturbing these top jobs using a different perturbation technique to avoid local optimum scheduling and minimize makespan.\\n\\nThe main steps involve calculating the machine load balance, identifying underloaded machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_load_balance = np.std(time_matrix, axis=0)\\n underloaded_machines = np.argsort(machine_load_balance)[:m]\\n \\n top_jobs = []\\n for machine in underloaded_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.0625,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines in the scheduling, select the top jobs from these machines, and apply a new perturbation technique to balance the load and minimize the makespan. The main steps include identifying the underutilized machines, selecting the top jobs from these machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.76562,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n \\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to identify the machines with the largest difference in execution time between the most and least time-consuming jobs, and select the top jobs from these machines to perturb. The perturbation will be applied to the selected jobs on all machines to update the time matrix and improve the scheduling, with the final goal of minimizing makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_times = np.max(time_matrix, axis=0)\\n min_execution_times = np.min(time_matrix, axis=0)\\n time_difference = max_execution_times - min_execution_times\\n delayed_machines = np.argsort(time_difference)[::-1][:m]\\n \\n top_jobs = []\\n for machine in delayed_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.84375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n perturb_jobs = np.unique(delayed_jobs)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed jobs by comparing their actual completion time with the expected completion time on the most delayed machines. Next, perturbations are applied to the execution time of the selected jobs on all machines, and the resulting matrix is returned with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.89062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n \\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to update the execution time matrix by calculating the machine load balance, selecting the top jobs from the underloaded machines, and perturbing these top jobs using a different perturbation technique to avoid local optimum scheduling and minimize makespan.\\n\\nThe main steps involve calculating the machine load balance, identifying underloaded machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_load_balance = np.std(time_matrix, axis=0)\\n underloaded_machines = np.argsort(machine_load_balance)[:m]\\n \\n top_jobs = []\\n for machine in underloaded_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.0625,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm will first identify the top delayed jobs based on their completion time compared to the expected completion time on the most delayed machines. It will then apply perturbations to the execution time of the selected jobs on all machines and return the resulting matrix with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.07812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines in the scheduling, select the top jobs from these machines, and apply a new perturbation technique to balance the load and minimize the makespan. The main steps include identifying the underutilized machines, selecting the top jobs from these machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.76562,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n \\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to identify the machines with the largest difference in execution time between the most and least time-consuming jobs, and select the top jobs from these machines to perturb. The perturbation will be applied to the selected jobs on all machines to update the time matrix and improve the scheduling, with the final goal of minimizing makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_times = np.max(time_matrix, axis=0)\\n min_execution_times = np.min(time_matrix, axis=0)\\n time_difference = max_execution_times - min_execution_times\\n delayed_machines = np.argsort(time_difference)[::-1][:m]\\n \\n top_jobs = []\\n for machine in delayed_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.84375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n perturb_jobs = np.unique(delayed_jobs)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed jobs by comparing their actual completion time with the expected completion time on the most delayed machines. Next, perturbations are applied to the execution time of the selected jobs on all machines, and the resulting matrix is returned with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.89062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines. The algorithm will also take into account the priority of jobs based on their due dates to ensure timely delivery.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n priority = np.arange(n) # random due dates for demonstration purposes\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n delayed_jobs = delayed_jobs[np.argsort(priority[delayed_jobs])][:m] # prioritize jobs based on their due dates\\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.9375,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run1/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm aims to identify the underutilized machines in the scheduling to balance the load and improve the overall makespan. The main steps include identifying the underutilized machines, selecting the top jobs from the underutilized machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Identify underutilized machines\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n # Select top jobs from underutilized machines\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n # Apply new perturbation technique\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3153.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm will first identify the top delayed jobs based on their completion time compared to the expected completion time on the most delayed machines. It will then apply perturbations to the execution time of the selected jobs on all machines and return the resulting matrix with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.07812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs. The main steps involve calculating the total execution time on each machine, identifying underutilized machines, selecting top jobs from these machines, perturbing the selected jobs, and returning the updated time matrix and list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify bottleneck machines in the scheduling by calculating the total execution time for each machine and then selecting the top jobs from the bottleneck machines. These selected jobs will undergo a novel perturbation technique to improve the overall makespan of the scheduling.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n bottleneck_machines = np.argsort(-machine_times)[:m]\\n\\n top_jobs = np.argmax(time_matrix[:, bottleneck_machines], axis=0)\\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.53125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the underutilized machines in the scheduling, select the top jobs from these machines, and apply a new perturbation technique to balance the load and minimize the makespan. The main steps include identifying the underutilized machines, selecting the top jobs from these machines, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n\\n top_jobs = []\\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.76562,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to update the execution time matrix by identifying underutilized machines, selecting the top jobs from these machines to perturb, applying a new perturbation technique to the selected jobs, and returning the updated time matrix along with the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_times = np.sum(time_matrix, axis=0)\\n underutilized_machines = np.argsort(machine_times)[:m]\\n top_jobs = []\\n \\n for machine in underutilized_machines:\\n top_job = np.argmin(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.8125,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: \\nThe new algorithm aims to identify the machines with the largest difference in execution time between the most and least time-consuming jobs, and select the top jobs from these machines to perturb. The perturbation will be applied to the selected jobs on all machines to update the time matrix and improve the scheduling, with the final goal of minimizing makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_times = np.max(time_matrix, axis=0)\\n min_execution_times = np.min(time_matrix, axis=0)\\n time_difference = max_execution_times - min_execution_times\\n delayed_machines = np.argsort(time_difference)[::-1][:m]\\n \\n top_jobs = []\\n for machine in delayed_machines:\\n top_job = np.argmax(time_matrix[:, machine])\\n top_jobs.append(top_job)\\n \\n perturb_jobs, jobs_counts = np.unique(top_jobs, return_counts=True)\\n perturb_jobs = perturb_jobs[np.argsort(-jobs_counts)][:m]\\n \\n new_matrix = time_matrix.copy()\\n \\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.84375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe novel algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n perturb_jobs = np.unique(delayed_jobs)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.875,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed jobs by comparing their actual completion time with the expected completion time on the most delayed machines. Next, perturbations are applied to the execution time of the selected jobs on all machines, and the resulting matrix is returned with the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n job_completion_time = time_matrix[current_sequence, delayed_machines]\\n delay_difference = job_completion_time - expected_completion_time[current_sequence]\\n delayed_jobs = np.argsort(-delay_difference)[:m] \\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.89062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe modified algorithm aims to identify the most delayed machines instead of bottleneck machines and select the top jobs from these machines to perturb. The perturbation technique will be based on the difference between the actual and expected completion time of jobs on the identified delayed machines. The algorithm will also take into account the priority of jobs based on their due dates to ensure timely delivery.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n delayed_machines = np.argmax(time_matrix, axis=1)\\n expected_completion_time = np.mean(time_matrix, axis=1)\\n priority = np.arange(n) # random due dates for demonstration purposes\\n delayed_jobs = np.where(time_matrix[current_sequence, delayed_machines] > expected_completion_time[current_sequence])[0]\\n delayed_jobs = delayed_jobs[np.argsort(priority[delayed_jobs])][:m] # prioritize jobs based on their due dates\\n perturb_jobs = np.unique(delayed_jobs)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.normal(1, 0.1, size=new_matrix.shape[1])\\n new_matrix[job] *= perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.9375,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nThe algorithm idea is to update the execution time matrix based on the current sequence of jobs and then select the top jobs to perturb in order to avoid being trapped in local optimum scheduling and minimize the makespan. The main steps include updating the execution time matrix based on the current job sequence and then selecting the top jobs to perturb based on their impact on the scheduling makespan.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Update execution time matrix\\n new_matrix = time_matrix.copy()\\n for i in range(n):\\n for j in range(m):\\n new_matrix[i][j] *= (n - np.where(current_sequence == i)[0][0])\\n\\n # Select top jobs to perturb\\n makespan = np.max(np.sum(new_matrix, axis=1))\\n job_impact = np.sum(new_matrix, axis=1) - makespan\\n perturb_jobs = np.argsort(job_impact)[-m:]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 10000000000.0,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm selects the top jobs based on their execution time on different machines, then perturbs the selected jobs in the current sequence to update the execution time matrix. First, it computes the average execution time of each job across all machines and selects the top jobs with the highest average execution time. Then, it randomly perturbs the selected jobs in the current sequence, updating the execution time matrix accordingly.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.60938,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the total execution time for each job in the current sequence, update the time matrix by increasing the execution time of the top jobs, and select the top jobs with the longest execution time to be perturbed for minimizing makespan.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = total_execution_time.argsort()[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n machine = np.argmin(np.sum(new_matrix, axis=0))\\n new_matrix[job][machine] += 1\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = total_execution_time.argsort()[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n machine = np.argmin(np.sum(new_matrix, axis=0))\\n new_matrix[job][machine] += 1\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3214.09375,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the makespan for each job by adding its execution time on each machine, then sort the jobs based on their makespan. After that, we update the time matrix by perturbing the execution time of the top jobs in the sequence. Finally, we select the top perturbed jobs as the ones with the highest makespan to avoid local optimum scheduling.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix, axis=1)\\n sorted_jobs = np.argsort(makespan)\\n new_matrix = time_matrix.copy()\\n perturb_jobs = sorted_jobs[-m:]\\n \\n for job in perturb_jobs:\\n new_matrix[job] += np.random.rand(m) # Perturb execution time\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix, axis=1)\\n sorted_jobs = np.argsort(makespan)\\n new_matrix = time_matrix.copy()\\n perturb_jobs = sorted_jobs[-m:]\\n \\n for job in perturb_jobs:\\n new_matrix[job] += np.random.rand(m) # Perturb execution time\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3218.98438,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\n The algorithm first calculates the makespan for the current sequence using the time matrix. Then, it identifies the top jobs that contribute most to the makespan and selects them for perturbation to avoid local optima.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(job_contributions)[::-1][:min(5, n)]\\n \\n # Update time matrix (example of random perturbation)\\n new_matrix = time_matrix\\n for job in perturb_jobs:\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)[-1]\\n job_contributions = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(job_contributions)[::-1][:min(5, n)]\\n \\n # Update time matrix (example of random perturbation)\\n new_matrix = time_matrix\\n for job in perturb_jobs:\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3174.32812,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm:\\n1. Calculate the completion time for each job on each machine based on the current time matrix.\\n2. Select the top jobs with the highest completion time on any machine to perturb.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n completion_time = np.zeros((n, m))\\n for i in range(n):\\n for j in range(m):\\n if j == 0:\\n completion_time[i][j] = time_matrix[current_sequence[i]][j]\\n else:\\n completion_time[i][j] = max(completion_time[i][j-1], completion_time[i][j-1]) + time_matrix[current_sequence[i]][j]\\n \\n total_completion_time = np.sum(completion_time, axis=1)\\n perturb_jobs = total_completion_time.argsort()[-m:]\\n\\n new_matrix = time_matrix.copy()\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3218.45312,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm initializes an empty list perturb_jobs and updates the time matrix by iterating through each job in the current_sequence and randomly selecting the execution time of the job on a different machine. It then calculates the makespan for each updated matrix and selects the top jobs from the current_sequence with the highest makespan to be perturbed.\\n}\\n```python\\nimport numpy as np\\nimport random\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = []\\n new_matrix = time_matrix.copy()\\n for job in current_sequence:\\n new_machine = random.choice([x for x in range(m) if x != job])\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n makespan = np.max(np.sum(new_matrix, axis=0))\\n perturb_jobs.append((job, makespan))\\n \\n perturb_jobs.sort(key=lambda x: x[1], reverse=True)\\n perturb_jobs = [x[0] for x in perturb_jobs][:m]\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\nimport random\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = []\\n new_matrix = time_matrix.copy()\\n for job in current_sequence:\\n new_machine = random.choice([x for x in range(m) if x != job])\\n new_matrix[job] = np.random.permutation(new_matrix[job])\\n makespan = np.max(np.sum(new_matrix, axis=0))\\n perturb_jobs.append((job, makespan))\\n \\n perturb_jobs.sort(key=lambda x: x[1], reverse=True)\\n perturb_jobs = [x[0] for x in perturb_jobs][:m]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3193.14062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\n- First, calculate the makespan for each job by considering the total execution time of all jobs on each machine in the current sequence.\\n- Next, select the top jobs with the highest makespan and update the execution time matrix accordingly, and return the updated matrix and the perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence], axis=0)\\n perturb_jobs = np.argsort(makespan)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3165.92188,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the new execution time matrix based on the current sequence of jobs and then select the top jobs to perturb based on the maximum difference in execution times across machines. First, calculate the execution time for each job on each machine according to the current sequence, then update the time matrix. Next, calculate the difference in execution times across machines for each job and select the top ones as perturb_jobs.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = np.zeros((n, m))\\n for i in range(n):\\n for j in range(m):\\n new_matrix[i][j] = time_matrix[current_sequence[i]][j]\\n \\n differences = np.max(new_matrix, axis=1) - np.min(new_matrix, axis=1)\\n perturb_jobs = np.argsort(differences)[::-1][:min(3, n)]\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = np.zeros((n, m))\\n for i in range(n):\\n for j in range(m):\\n new_matrix[i][j] = time_matrix[current_sequence[i]][j]\\n \\n differences = np.max(new_matrix, axis=1) - np.min(new_matrix, axis=1)\\n perturb_jobs = np.argsort(differences)[::-1][:min(3, n)]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3196.64062,\n \"first_obj\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm idea is to calculate the makespan for each job by updating the execution time matrix based on the current sequence, then select the top jobs with the highest makespan to perturb and avoid local optimum scheduling. \\nFirst, calculate the makespan for each job using the current sequence and time matrix. Then, select the top jobs with the highest makespan to perturb. Update the execution time matrix for the selected jobs, and return the new matrix and the perturb jobs list.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n current_makespan = np.max(np.cumsum(time_matrix[current_sequence], axis=1), axis=0)\\n perturb_jobs = current_makespan.argsort()[-min(2, n):]\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] += 1\\n return new_matrix, perturb_jobs\",\n \"objective\": 3208.95312,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.34375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the total execution time of each job on each machine in the current sequence, then selects the top jobs with the highest total execution time per machine to perturb and update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.48438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their total execution time across all machines, then perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3160.42188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: \\nThe new algorithm selects the top jobs based on their maximum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.9 and 1.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3160.9375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nCommon backbone idea: Selecting the top jobs based on specific criteria and perturbing their execution time in the current sequence to update the time matrix.\\n\\nNew algorithm description: \\nThe new algorithm selects the top jobs based on their average execution time across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3160.95312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Choose the top jobs with the highest total execution time on different machines and perturb them in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3161.0625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the total execution time of each job on each machine in the current sequence and then selects top jobs with the highest total execution time to perturb and update the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their maximum execution time on different machines, then perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.7 and 1.3.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.7, 1.3)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.0625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their maximum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.9 and 1.1.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.23438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm selects the top jobs based on their execution time on different machines, then perturbs the selected jobs in the current sequence to update the execution time matrix. First, it computes the average execution time of each job across all machines and selects the top jobs with the highest average execution time. Then, it randomly perturbs the selected jobs in the current sequence, updating the execution time matrix accordingly.\\n}\\n\\n```python\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(average_execution_time)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.9, 1.1)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.60938,\n \"first_obj\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects a subset of machines, calculates their average execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor between 0.5 and 1.5.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n average_execution_time = np.mean(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.5, 1.5) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of machines, calculates their average execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor between 0.5 and 1.5, and also checks for any machine with a low utilization rate and reshuffles the jobs on that machine to balance the load.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n average_execution_time = np.mean(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.5, 1.5) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n low_utilization_machines = np.where(np.sum(new_matrix, axis=0) < np.max(np.sum(new_matrix, axis=0) * 0.2))[0]\\n for machine in low_utilization_machines:\\n job_order = np.argsort(new_matrix[:, machine])\\n new_matrix[:, machine] = new_matrix[job_order, machine]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.17188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their weighted sum of execution times on different machines, perturbs them in the current sequence, and updates the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.9, 1.1) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.20312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects a subset of machines, calculates the standard deviation of execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying a random perturbation factor between 0.7 and 1.3.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n std_execution_time = np.std(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.7, 1.3) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.21875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects a subset of machines, calculates the median execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor between 0.5 and 1.5.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n median_execution_time = np.median(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.5, 1.5) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.75,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by a combination of random selection and considering the ratio of execution times, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n random_perturb_jobs = np.random.choice(n, m // 2, replace=False)\\n ratio_based_perturb_jobs = np.argsort(execution_time_ratio)[-m // 2:]\\n \\n perturb_jobs = np.concatenate((random_perturb_jobs, ratio_based_perturb_jobs))\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.03125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time, and also checks for any machine with a high utilization rate and reshuffles the jobs on that machine to balance the load.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n utilization_rate = np.sum(time_matrix, axis=0) / np.sum(time_matrix)\\n high_utilization_machines = np.where(utilization_rate > 0.8)[0]\\n \\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, min(m, n), replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n for machine in high_utilization_machines:\\n job_order = np.argsort(new_matrix[:, machine])\\n new_matrix[:, machine] = new_matrix[job_order, machine]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.625,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.45312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the lowest execution time on different machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.15625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.34375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the ratio of maximum to minimum execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.42188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the total execution time of each job on each machine in the current sequence, then selects the top jobs with the highest total execution time per machine to perturb and update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.48438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n job_perturbation_range = (0.85, 1.15)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(*job_perturbation_range)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.09375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the average execution time of each job on each machine in the current sequence, then identifies the top jobs with execution times above the average for each machine to perturb and update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.where(time_matrix[current_sequence] > avg_execution_time[:, None])[0]\\n perturb_jobs = np.unique(perturb_jobs)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm first calculates the average execution time of each job on each machine in the current sequence, then selects the top jobs with the highest average execution time per machine to perturb and update the execution time matrix by multiplying their execution time with a random factor between 0.75 and 1.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(avg_execution_time)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.75, 1.25)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.48438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the maximum difference between the execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.75 and 1.25.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.ptp(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.75, 1.25)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.79688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs with the longest execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.96875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.45312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2)*new_matrix[job]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.82812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm selects the top jobs with the lowest total execution time across machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.04688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the lowest execution time on different machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.15625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the ratio of maximum execution time to minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.17188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on the ratio of total execution time to the maximum execution time on each machine, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=0)\\n max_execution_time = np.max(time_matrix, axis=0)\\n execution_time_ratio = total_execution_time / max_execution_time\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.3125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.34375,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.45312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the difference between maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.48438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2)*new_matrix[job]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.82812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm selects the top jobs with the lowest total execution time across machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.04688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the highest coefficient of variation of execution time on different machines, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n coefficient_of_variation = np.std(time_matrix, axis=1) / np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(coefficient_of_variation)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the lowest execution time on different machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.15625,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\\nCode:\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.15625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest ratio of execution time on different machines, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.25,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\\nCode:\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.15625,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the ratio of maximum difference to the sum of execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_diff_sum_ratio = np.max(time_matrix, axis=1) / np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_diff_sum_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.89062,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their average execution time on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_exec_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=average_exec_time/np.sum(average_exec_time))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.09375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, min(m, n), replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.20312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run2/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by a combination of random selection and considering the ratio of execution times, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n random_perturb_jobs = np.random.choice(n, m // 2, replace=False)\\n ratio_based_perturb_jobs = np.argsort(execution_time_ratio)[-m // 2:]\\n \\n perturb_jobs = np.concatenate((random_perturb_jobs, ratio_based_perturb_jobs))\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.03125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time, and also checks for any machine with a high utilization rate and reshuffles the jobs on that machine to balance the load.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n utilization_rate = np.sum(time_matrix, axis=0) / np.sum(time_matrix)\\n high_utilization_machines = np.where(utilization_rate > 0.8)[0]\\n \\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, min(m, n), replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n for machine in high_utilization_machines:\\n job_order = np.argsort(new_matrix[:, machine])\\n new_matrix[:, machine] = new_matrix[job_order, machine]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their weighted sum of execution times on different machines, perturbs them in the current sequence, and updates the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects a subset of machines, calculates their maximum execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying or dividing a random perturbation factor between 0.7 and 1.3.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n max_execution_time = np.max(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.7, 1.3) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.79688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their weighted sum of execution times on different machines, perturbs them in the current sequence, and updates the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.98438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb by calculating the average execution time for each job across all machines, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(avg_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.5,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm starts by calculating the makespan of the current sequence using the given time matrix. \\nNext, it updates the execution time matrix by iterating through each machine and selecting the job with the maximum execution time and perturbing its execution time randomly. \\nFinally, it selects the top jobs to be perturbed based on their execution time on each machine.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n for i in range(m):\\n max_execution_time = np.max(new_matrix[:, i])\\n max_jobs = np.where(new_matrix[:, i] == max_execution_time)[0]\\n perturb_job = np.random.choice(max_jobs)\\n perturb_time = np.random.uniform(0.1 * max_execution_time, 0.9 * max_execution_time)\\n new_matrix[perturb_job, i] = perturb_time\\n\\n perturb_jobs = np.argsort(np.sum(new_matrix, axis=1))[-5:]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3178.9375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm selects the top jobs with the highest execution times on each machine and perturbs their sequence by swapping adjacent jobs to avoid being trapped in the local optimum scheduling. Then it updates the execution time matrix by recalculating the execution times of the perturbed jobs on each machine. \\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = []\\n new_matrix = np.copy(time_matrix)\\n\\n for machine in range(m):\\n sorted_jobs = np.argsort(time_matrix[:, machine])[::-1]\\n top_jobs = sorted_jobs[:2]\\n perturb_jobs.extend(top_jobs)\\n current_sequence[machine], current_sequence[machine+1] = current_sequence[machine+1], current_sequence[machine]\\n \\n for job in perturb_jobs:\\n for machine in range(m):\\n new_matrix[job, machine] = np.sum(current_sequence[:machine+1])\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3186.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the execution time matrix based on the current sequence of jobs and selects the top jobs to perturb in order to minimize the makespan.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_scores = np.zeros(n)\\n \\n for i in range(n):\\n job_scores[i] = np.sum(time_matrix[i])\\n \\n perturb_jobs = np.argsort(-job_scores)[:m]\\n \\n new_matrix = np.copy(time_matrix)\\n for job in perturb_jobs:\\n for machine in range(m):\\n new_matrix[job][machine] += np.max(new_matrix[:,machine]) - time_matrix[job][machine]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3189.89062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm aims to minimize the makespan by updating the execution time matrix and selecting the top jobs to perturb.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = np.copy(time_matrix)\\n perturb_jobs = []\\n \\n # Step 1: Calculate the makespan for the current sequence\\n makespan = np.max(np.sum(new_matrix[current_sequence], axis=0))\\n \\n # Step 2: Iterate over each job in the current sequence\\n for job in current_sequence:\\n # Step 3: Remove the current job from the new matrix\\n temp_matrix = np.delete(new_matrix, job, axis=0)\\n \\n # Step 4: Calculate the makespan without the current job\\n temp_makespan = np.max(np.sum(temp_matrix, axis=0))\\n \\n # Step 5: If the makespan without the current job is less than the makespan with the current sequence,\\n # perturb the current job by randomly selecting a different job and update the new matrix\\n if temp_makespan < makespan:\\n perturb_jobs.append(job)\\n available_jobs = np.arange(n)\\n available_jobs = np.delete(available_jobs, job)\\n perturbed_job = np.random.choice(available_jobs)\\n new_matrix[job] = time_matrix[perturbed_job]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3190.03125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm aims to update the execution time matrix by perturbing the top jobs in the current sequence such that the local optimum scheduling is avoided and a scheduling with minimized makespan is achieved. \\n\\n1. Initialize an empty list named 'perturb_jobs'.\\n\\n2. Create a copy of the 'time_matrix' and store it in the variable 'new_matrix'.\\n\\n3. Sort the 'current_sequence' based on the sum of execution times for each job across all machines in descending order.\\n\\n4. Iterate through each job in the sorted 'current_sequence':\\n\\n a. Select the execution time row corresponding to the current job from 'new_matrix'.\\n \\n b. Find the machine with the maximum execution time for the current job.\\n \\n c. Select the execution time column corresponding to the machine with maximum execution time.\\n \\n d. Find the job with the minimum execution time on the selected machine.\\n \\n e. Perturb the current job with the job found in step d by swapping their execution times in 'new_matrix'.\\n \\n f. Append the current job to the 'perturb_jobs' list.\\n \\n5. Return 'new_matrix' and 'perturb_jobs' as the outputs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = []\\n\\n new_matrix = np.copy(time_matrix)\\n\\n sorted_sequence = sorted(current_sequence, key=lambda j: np.sum(time_matrix[j]), reverse=True)\\n\\n for job in sorted_sequence:\\n execution_time_row = new_matrix[job]\\n machine_with_max_exec_time = np.argmax(execution_time_row)\\n execution_time_column = new_matrix[:, machine_with_max_exec_time]\\n job_with_min_exec_time = np.argmin(execution_time_column)\\n new_matrix[job][machine_with_max_exec_time], new_matrix[job_with_min_exec_time][machine_with_max_exec_time] = new_matrix[job_with_min_exec_time][machine_with_max_exec_time], new_matrix[job][machine_with_max_exec_time]\\n perturb_jobs.append(job)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3191.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm selects the top jobs with the longest execution times on each machine and perturbs them by swapping their positions with the adjacent jobs in the current sequence. Then, it updates the execution time matrix based on the new sequence.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n # Step 1: Calculate the execution time for each job on each machine based on the current sequence\\n execution_times = np.zeros((m, n))\\n for i in range(m):\\n for j in range(n):\\n execution_times[i][j] = time_matrix[current_sequence[j]][i]\\n \\n # Step 2: Determine the jobs with the longest execution times on each machine\\n max_execution_times = np.max(execution_times, axis=0)\\n perturb_jobs = np.argsort(max_execution_times)[-m:]\\n \\n # Step 3: Perturb the selected jobs by swapping their positions with adjacent jobs in the current sequence\\n new_sequence = np.copy(current_sequence)\\n for job in perturb_jobs:\\n job_index = np.where(new_sequence == job)[0][0]\\n if job_index > 0:\\n new_sequence[job_index], new_sequence[job_index-1] = new_sequence[job_index-1], new_sequence[job_index]\\n elif job_index < n-1:\\n new_sequence[job_index], new_sequence[job_index+1] = new_sequence[job_index+1], new_sequence[job_index]\\n \\n # Step 4: Update the execution time matrix based on the new sequence\\n new_matrix = np.zeros((n, m))\\n for i in range(m):\\n for j in range(n):\\n new_matrix[j][i] = time_matrix[new_sequence[j]][i]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3197.51562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm selects the top jobs from the current sequence based on their execution time on the machines, and perturbs them by swapping each of them with all other jobs to update the execution time matrix, resulting in the updated matrix and the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_times = np.sum(time_matrix, axis=1)\\n sorted_jobs = np.argsort(execution_times)[::-1]\\n perturb_jobs = sorted_jobs[:min(m, n)]\\n new_matrix = time_matrix.copy()\\n \\n for i in perturb_jobs:\\n for j in range(n):\\n if j != i:\\n new_matrix[i], new_matrix[j] = new_matrix[j].copy(), new_matrix[i].copy()\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3201.65625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb based on their execution time on the machines and the current sequence of jobs.\\n1. Create an empty list called 'perturb_jobs'.\\n2. Calculate the makespan for the current sequence of jobs using the time matrix.\\n3. Find the machine with the maximum makespan and store its index in a variable 'max_machine'.\\n4. For each job in 'current_sequence':\\n - Calculate the execution time of the job on 'max_machine' using the time matrix.\\n - Append a tuple containing the job index and its execution time on 'max_machine' to 'perturb_jobs'.\\n5. Sort 'perturb_jobs' based on the execution time in descending order.\\n6. Select the first m jobs from 'perturb_jobs' and store them in 'perturb_jobs'.\\n7. Update the time matrix by swapping the execution time of the jobs in 'perturb_jobs' with the execution time of the jobs in 'current_sequence'.\\n8. Return 'new_matrix' as the updated time matrix and 'perturb_jobs' as the selected jobs to be perturbed.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = []\\n new_matrix = np.copy(time_matrix)\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=0))\\n max_machine = np.argmax(np.sum(time_matrix[current_sequence], axis=0))\\n \\n for job in current_sequence:\\n job_execution_time = time_matrix[job][max_machine]\\n perturb_jobs.append((job, job_execution_time))\\n \\n perturb_jobs = sorted(perturb_jobs, key=lambda x: x[1], reverse=True)\\n perturb_jobs = [job[0] for job in perturb_jobs[:m]]\\n \\n for job in perturb_jobs:\\n new_matrix[job] = time_matrix[current_sequence[perturb_jobs.index(job)]]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3201.95312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the completion time of each job on each machine, then updates the execution time matrix based on the completion times, and finally selects the top jobs with the highest completion times to perturb.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n completion_time = np.zeros((n, m))\\n \\n for i in range(n):\\n for j in range(m):\\n if j == 0:\\n completion_time[i][j] = time_matrix[current_sequence[i]][j]\\n else:\\n completion_time[i][j] = time_matrix[current_sequence[i]][j] + completion_time[i][j-1]\\n \\n new_matrix = time_matrix.copy()\\n \\n for j in range(m):\\n sorted_jobs = np.argsort(completion_time[:, j])\\n perturb_jobs = sorted_jobs[-int(0.1*n):]\\n \\n for job in perturb_jobs:\\n new_matrix[:, j] = np.roll(new_matrix[:, j], 1)\\n new_matrix[j][0] = 0\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3204.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm selects the machines with the longest execution time for each job, updates the execution time matrix to increase the execution time of the selected machines, and selects the top jobs with the highest execution time as perturb_jobs.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_by_machine = np.sum(time_matrix, axis=0) # Calculate the total execution time by machine\\n selected_machines = np.argmax(time_matrix, axis=1) # Select the machines with the longest execution time for each job\\n perturb_jobs = np.argsort(execution_time_by_machine)[-n:] # Select the top jobs with the highest execution time\\n new_matrix = np.copy(time_matrix) # Create a copy of the time matrix\\n \\n for job_index in range(n):\\n machine_to_perturb = selected_machines[job_index] # Get the machine to perturb for the current job\\n new_matrix[job_index][machine_to_perturb] += 1 # Increase the execution time of the selected machine for the current job\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3204.95312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nMy new algorithm involves the following steps:\\nStep 1: Calculate the makespan of the current sequence using the time matrix.\\nStep 2: Perturb the current sequence by swapping adjacent jobs and calculate the makespan for each perturbed sequence.\\nStep 3: Find the top-k jobs with the highest execution time in the current sequence and add them to the perturb_jobs list.\\nStep 4: For each job in the perturb_jobs list, iterate through all the machines and update the execution time in the time matrix by a random value between a specified range.\\nStep 5: Return the updated time matrix as new_matrix and the perturb_jobs list as perturb_jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.sum(time_matrix[current_sequence[-1]])\\n perturb_jobs = np.argsort(np.max(time_matrix, axis=1))[::-1][:min(m, n)]\\n new_matrix = np.copy(time_matrix)\\n for job in perturb_jobs:\\n for machine in range(m):\\n new_matrix[job][machine] += np.random.uniform(-1, 1)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3211.90625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm updates the execution time matrix by considering the current sequence of jobs and selects the top jobs to perturb based on their execution times.\",\n \"code\": \"def get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = np.copy(time_matrix)\\n perturb_jobs = np.zeros(n, dtype=int)\\n for i in range(n):\\n perturb_jobs[i] = i\\n return new_matrix, perturb_jobs\",\n \"objective\": 3216.625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm updates the execution time matrix by swapping the execution times of randomly selected pairs of jobs on the same machine until no further improvement is possible, and selects the top jobs with the longest execution times to be perturbed.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = time_matrix.copy()\\n perturb_jobs = np.argsort(-new_matrix.sum(axis=1))[:m]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3216.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the jobs with the top execution times on each machine, updates the execution time matrix by subtracting a certain amount of time from the selected jobs, and returns the updated matrix and the list of perturbed jobs.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n top_jobs = np.argmax(time_matrix, axis=1)\\n perturb_jobs = [current_sequence[i] for i in top_jobs]\\n new_matrix = time_matrix.copy()\\n \\n for i, j in enumerate(top_jobs):\\n new_matrix[j] -= np.max(time_matrix[j]) / 2\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3217.65625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the completion time of each job on each machine using the current sequence and time matrix, then updates the execution time matrix by subtracting the completion time of each job on the corresponding machine from the execution time matrix, finally selects the top jobs with the maximum execution time on each machine and returns the updated time matrix and the perturb jobs.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n completion_time = np.zeros((n, m))\\n\\n for i in range(n):\\n for j in range(m):\\n if j == 0:\\n completion_time[i][j] = time_matrix[current_sequence[i]][j]\\n else:\\n completion_time[i][j] = completion_time[i][j-1] + time_matrix[current_sequence[i]][j]\\n\\n new_matrix = time_matrix - completion_time\\n\\n perturb_jobs = np.argmax(new_matrix, axis=0)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3218.17188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"This algorithm selects the machine with the shortest total execution time and perturbs the job with the longest execution time on that machine, updating the execution time matrix accordingly.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-m:]\\n\\n max_exec_time_machine = np.argmin(np.sum(time_matrix, axis=0))\\n max_exec_time_job = np.argmax(time_matrix[:, max_exec_time_machine])\\n\\n new_matrix = np.copy(time_matrix)\\n new_matrix[max_exec_time_job, max_exec_time_machine] *= 1.1\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3219.34375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"My new algorithm first creates a copy of the time matrix. Then, it calculates the makespan for each job by summing up the execution time on each machine. It then sorts the jobs in ascending order of their makespan. Next, it selects the top jobs based on a predefined limit and adds them to the perturb_jobs list. Finally, it perturbs the execution time of the selected jobs in the copy of the time matrix by adding a small random value, and returns the updated matrix and the list of perturbed jobs.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n new_matrix = np.copy(time_matrix)\\n \\n makespan = np.sum(time_matrix, axis=1)\\n sorted_jobs = np.argsort(makespan)\\n \\n limit = min(m, n) // 4 # Predefined limit for selecting top jobs\\n \\n perturb_jobs = sorted_jobs[:limit]\\n \\n for job in perturb_jobs:\\n new_matrix[job] += np.random.rand(m) * 0.001 # Perturb the execution time of selected jobs\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3437502242.54688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The algorithm selects a set of jobs to perturb by calculating the difference between the execution time of each job on its assigned machine and the execution time of the same job on the fastest machine, and then updates the execution time matrix by reducing the execution time of the perturbed jobs based on a perturbation factor.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n fastest_machine_index = np.argmin(np.sum(time_matrix, axis=1))\\n perturb_jobs = np.argsort(time_matrix[:, fastest_machine_index] - np.min(time_matrix, axis=1))[::-1][:m]\\n perturbation_factor = 0.9\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs, :] *= perturbation_factor\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 8593750477.73438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nCreate a list of completion times for each job sequence using the given time matrix and current job sequence, then update the time matrix by subtracting the minimum completion time from each element in the matrix, and select the top jobs to perturb based on a criteria (such as randomly selecting jobs with higher execution times or jobs with larger differences in completion times).\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n completion_times = np.zeros(n)\\n for i in range(n):\\n for j in range(m):\\n machine = current_sequence[i]\\n completion_times[i] += time_matrix[i][machine]\\n min_completion_time = np.min(completion_times)\\n updated_matrix = time_matrix - min_completion_time\\n perturb_jobs = np.argsort(completion_times)[-int(n/5):] # Select top 20% jobs to perturb\\n return new_matrix, perturb_jobs\",\n \"objective\": 10000000000.0,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_1.json", "content": "[\n {\n \"algorithm\": \"Algorithm description: The new algorithm selects the top jobs to perturb by calculating the sum of execution time for each job across all machines, updating the execution time matrix by dividing the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n sum_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(sum_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix / perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb by calculating the variance of execution time for each job across all machines, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n variance_execution_time = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(variance_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.14062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs to perturb by calculating the minimum execution time for each job across all machines, updating the execution time matrix by dividing the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix / perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.20312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb by calculating the maximum execution time for each job across all machines, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description:\\nThe new algorithm selects the top jobs to perturb by calculating a weighted score for each job based on the execution time on each machine and a user-defined scoring function, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n weights = [0.5, 0.3, 0.2] # User-defined weight values\\n scores = np.zeros(n)\\n for i in range(n):\\n job_times = time_matrix[i]\\n job_score = sum([w*t for (w, t) in zip(weights, job_times)])\\n scores[i] = job_score\\n perturb_jobs = np.argsort(scores)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb by calculating the average execution time for each job across all machines, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(avg_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.5,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb based on their position in the current job sequence, updates the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor, and returns the perturbed jobs and the updated matrix.\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.argsort(current_sequence)[:n // 2]\\n perturbation_factors = np.random.uniform(0.9, 1.1, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.04688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description:\\n\\nThe algorithm starts by calculating the makespan of the current sequence using the given time matrix. Then, it selects a machine randomly. Next, it selects the job with the longest execution time on that machine. Finally, it perturbs the execution time of the selected job within a lower range and a higher range. This process is repeated for a specified number of iterations, and at the end, it selects the top jobs to be perturbed based on their execution time on each machine, considering the jobs with the longest execution time.\\n\\nNew code implementation for the function get_matrix_and_jobs:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n num_iterations = 10\\n\\n for _ in range(num_iterations):\\n machine = np.random.randint(0, m)\\n longest_job = np.argmax(new_matrix[:, machine])\\n perturb_range = 0.2 * new_matrix[longest_job, machine]\\n perturb_time = np.random.uniform(new_matrix[longest_job, machine] - perturb_range, new_matrix[longest_job, machine] + perturb_range)\\n new_matrix[longest_job, machine] = perturb_time\\n\\n perturb_jobs = np.argsort(np.max(new_matrix, axis=1))[-5:]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.53125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe algorithm starts by calculating the makespan of the current sequence using the given time matrix. Then, it updates the execution time matrix by randomly selecting a job on each machine and perturbing its execution time within a higher range and a lower range. Finally, it selects the top jobs to be perturbed based on their execution time on each machine, considering the jobs with the shortest execution time.\\n\\nNew code implementation for the function get_matrix_and_jobs:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n for i in range(m):\\n perturb_job = np.random.randint(0, n)\\n perturb_time = np.random.uniform(0.8 * new_matrix[perturb_job, i], 0.2 * new_matrix[perturb_job, i])\\n new_matrix[perturb_job, i] = perturb_time\\n\\n perturb_jobs = np.argsort(np.max(new_matrix, axis=1))[:5]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3160.625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm selects the top jobs to perturb by calculating the maximum execution time for each machine, updating the execution time matrix by multiplying the execution time of each job on each machine by a randomly generated perturbation factor within a specific range, and returns the perturbed jobs and the updated matrix.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=0)\\n perturb_jobs = np.argsort(max_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3161.04688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm starts by calculating the makespan of the current sequence using the given time matrix. Next, it updates the execution time matrix by iterating through each machine and selecting the job with the maximum execution time. It perturbs the execution time of the selected job within a higher range, based on a different parameter setting of the score function. Finally, it selects the top jobs to be perturbed based on their execution time, considering the jobs with the shortest execution time on each machine.\\n\\nNew code implementation for the function get_matrix_and_jobs:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n for i in range(m):\\n max_execution_time = np.max(new_matrix[:, i])\\n max_jobs = np.where(new_matrix[:, i] == max_execution_time)[0]\\n perturb_job = np.random.choice(max_jobs)\\n # New parameter settings of the score function\\n perturb_time = np.random.uniform(1.1 * max_execution_time, 1.5 * max_execution_time)\\n new_matrix[perturb_job, i] = perturb_time\\n\\n perturb_jobs = np.argsort(np.max(new_matrix, axis=1))[:5]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3161.59375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb by calculating the average execution time for each job on each machine, updating the execution time matrix by multiplying the execution time of each job on each machine by a randomly generated perturbation factor within a specific range, and returns the perturbed jobs and the updated matrix.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(avg_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3161.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe algorithm begins by calculating the makespan of the current sequence using the given time matrix. Then, it updates the execution time matrix by randomly selecting a job on each machine and perturbing its execution time within a lower range and a higher range. Finally, it selects the top jobs to be perturbed based on their execution time on each machine, considering the jobs with the longest execution time.\\n\\nNew code implementation for the function get_matrix_and_jobs:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n for i in range(m):\\n perturb_job = np.random.randint(0, n)\\n perturb_time = np.random.uniform(0.2 * new_matrix[perturb_job, i], 0.8 * new_matrix[perturb_job, i])\\n new_matrix[perturb_job, i] = perturb_time\\n\\n perturb_jobs = np.argsort(-np.max(new_matrix, axis=1))[:5]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3162.25,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: The new algorithm selects the top jobs to perturb by calculating the minimum execution time for each job across all machines, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor between 0.8 and 1.2, and returns the perturbed jobs and the updated matrix.\\n\\nCode:\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3162.70312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"Algorithm description: The new algorithm selects the top jobs to perturb by calculating the maximum execution time for each job across all machines, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor within the range [0.8, 1.2], and returns the perturbed jobs and the updated matrix.\\n\\nCode:\\n\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3163.15625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe algorithm starts by calculating the makespan of the current sequence using the given time matrix. Then, it updates the execution time matrix by randomly selecting a job on each machine and perturbing its execution time within a lower range and a higher range. Finally, it selects the top jobs to be perturbed based on their execution time on each machine, considering the jobs with the longest execution time.\\n\\nNew code implementation for the function get_matrix_and_jobs:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n for i in range(m):\\n perturb_job = np.random.randint(0, n)\\n perturb_time = np.random.uniform(1.2 * new_matrix[perturb_job, i], 0.8 * new_matrix[perturb_job, i])\\n new_matrix[perturb_job, i] = perturb_time\\n\\n perturb_jobs = np.argsort(np.max(new_matrix, axis=1))[-5:]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3165.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"New algorithm description: \\n\\nThe algorithm starts by calculating the makespan of the current sequence using the given time matrix. Then, it updates the execution time matrix by randomly selecting a job on each machine and perturbing its execution time within a higher range and a lower range. Finally, it selects the top jobs to be perturbed based on their execution time on each machine, considering the jobs with the longest execution time.\\n\\nNew code implementation for the function get_matrix_and_jobs:\\n\\n```\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n for i in range(m):\\n perturb_job = np.random.randint(0, n)\\n perturb_time = np.random.uniform(1.2 * new_matrix[perturb_job, i], 0.8 * new_matrix[perturb_job, i])\\n new_matrix[perturb_job, i] = perturb_time\\n\\n perturb_jobs = np.argsort(np.max(new_matrix, axis=1))[::-1][:5]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3166.375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs to perturb by calculating the maximum execution time for each job across all machines, updating the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor from a given range, and returns the perturbed jobs and the updated matrix.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.7, 1.3, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3168.5625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm starts by calculating the makespan of the current sequence using the given time matrix. Then, it updates the execution time matrix by randomly selecting a job on each machine and perturbing its execution time within a different range. Finally, it selects the top jobs to be perturbed based on their execution time on each machine, considering the jobs with the shortest execution time.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n makespan = np.max(np.sum(time_matrix[current_sequence], axis=1))\\n new_matrix = time_matrix.copy()\\n\\n for i in range(m):\\n perturb_job = np.random.randint(0, n)\\n perturb_time = np.random.uniform(0.8 * new_matrix[perturb_job, i], 1.2 * new_matrix[perturb_job, i])\\n new_matrix[perturb_job, i] = perturb_time\\n\\n perturb_jobs = np.argsort(np.min(new_matrix, axis=1))[:5]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3168.60938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs to perturb based on a score function that calculates the sum of execution times for each job across all machines, updates the execution time matrix by multiplying the execution time of each job on each machine by a random perturbation factor within the range [0.7, 1.3], and returns the perturbed jobs and the updated matrix.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n sum_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(sum_execution_time)[:n // 2]\\n perturbation_factors = np.random.uniform(0.7, 1.3, size=(n, m))\\n new_matrix = time_matrix * perturbation_factors\\n return new_matrix, perturb_jobs\",\n \"objective\": 3168.85938,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_10.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects a subset of machines, calculates their average execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor between 0.5 and 1.5.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n average_execution_time = np.mean(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.5, 1.5) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.01562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of machines, calculates their average execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor between 0.5 and 1.5, and also checks for any machine with a low utilization rate and reshuffles the jobs on that machine to balance the load.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n average_execution_time = np.mean(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.5, 1.5) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n low_utilization_machines = np.where(np.sum(new_matrix, axis=0) < np.max(np.sum(new_matrix, axis=0) * 0.2))[0]\\n for machine in low_utilization_machines:\\n job_order = np.argsort(new_matrix[:, machine])\\n new_matrix[:, machine] = new_matrix[job_order, machine]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.17188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their weighted sum of execution times on different machines, perturbs them in the current sequence, and updates the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.9, 1.1) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.20312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects a subset of machines, calculates the standard deviation of execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying a random perturbation factor between 0.7 and 1.3.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n std_execution_time = np.std(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.7, 1.3) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.21875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects a subset of machines, calculates the median execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor between 0.5 and 1.5.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n median_execution_time = np.median(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.5, 1.5) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.75,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by a combination of random selection and considering the ratio of execution times, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n random_perturb_jobs = np.random.choice(n, m // 2, replace=False)\\n ratio_based_perturb_jobs = np.argsort(execution_time_ratio)[-m // 2:]\\n \\n perturb_jobs = np.concatenate((random_perturb_jobs, ratio_based_perturb_jobs))\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.03125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time, and also checks for any machine with a high utilization rate and reshuffles the jobs on that machine to balance the load.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n utilization_rate = np.sum(time_matrix, axis=0) / np.sum(time_matrix)\\n high_utilization_machines = np.where(utilization_rate > 0.8)[0]\\n \\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, min(m, n), replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n for machine in high_utilization_machines:\\n job_order = np.argsort(new_matrix[:, machine])\\n new_matrix[:, machine] = new_matrix[job_order, machine]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.625,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_2.json", "content": "[\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.45312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the lowest execution time on different machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.15625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.34375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the ratio of maximum to minimum execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.42188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm first calculates the total execution time of each job on each machine in the current sequence, then selects the top jobs with the highest total execution time per machine to perturb and update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.48438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n job_perturbation_range = (0.85, 1.15)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(*job_perturbation_range)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.09375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm first calculates the average execution time of each job on each machine in the current sequence, then identifies the top jobs with execution times above the average for each machine to perturb and update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.where(time_matrix[current_sequence] > avg_execution_time[:, None])[0]\\n perturb_jobs = np.unique(perturb_jobs)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew Algorithm Description: The new algorithm first calculates the average execution time of each job on each machine in the current sequence, then selects the top jobs with the highest average execution time per machine to perturb and update the execution time matrix by multiplying their execution time with a random factor between 0.75 and 1.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n avg_execution_time = np.mean(time_matrix[current_sequence], axis=1)\\n perturb_jobs = np.argsort(avg_execution_time)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.75, 1.25)\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.48438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the maximum difference between the execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.75 and 1.25.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.ptp(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.75, 1.25)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.79688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs with the longest execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_execution_time = np.max(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3159.96875,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_3.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.45312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2)*new_matrix[job]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.82812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm selects the top jobs with the lowest total execution time across machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.04688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the lowest execution time on different machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.15625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the ratio of maximum execution time to minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.17188,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on the ratio of total execution time to the maximum execution time on each machine, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=0)\\n max_execution_time = np.max(time_matrix, axis=0)\\n execution_time_ratio = total_execution_time / max_execution_time\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.3125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on their minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.34375,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_4.json", "content": "[\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.45312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the difference between maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.48438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest standard deviation of execution time across all machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_std = np.std(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_std)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2)*new_matrix[job]\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.82812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nAlgorithm description: The new algorithm selects the top jobs with the lowest total execution time across machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n total_execution_time = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(total_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.04688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on the highest coefficient of variation of execution time on different machines, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n coefficient_of_variation = np.std(time_matrix, axis=1) / np.mean(time_matrix, axis=1)\\n perturb_jobs = np.argsort(coefficient_of_variation)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the lowest execution time on different machines and perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.85 and 1.15.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n min_execution_time = np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(min_execution_time)[:m]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.85, 1.15)\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3158.15625,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_5.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\\nCode:\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.15625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs with the highest ratio of execution time on different machines, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.25,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_6.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the maximum difference between execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_difference = np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_difference)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.10938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\\nCode:\\nimport numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3157.15625,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_7.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] *= np.random.uniform(0.8, 1.2)\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.8125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the ratio of maximum difference to the sum of execution times on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n max_diff_sum_ratio = np.max(time_matrix, axis=1) / np.sum(time_matrix, axis=1)\\n perturb_jobs = np.argsort(max_diff_sum_ratio)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.89062,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_8.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their average execution time on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n average_exec_time = np.mean(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=average_exec_time/np.sum(average_exec_time))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.09375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, min(m, n), replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.20312,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects 'm' jobs to perturb in the current sequence by adding or subtracting a random perturbation factor to their execution time, then updates the execution time matrix accordingly.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.35938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs based on the absolute difference between the maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by applying a random perturbation factor to their execution time within the range of -0.25 to 0.25.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_diff = np.abs(np.max(time_matrix, axis=1) - np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(execution_time_diff)[-m:]\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.25, 0.25) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.64062,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs based on their execution time variance across all machines, perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying their execution time by a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_variance = np.var(time_matrix, axis=1)\\n perturb_jobs = np.argsort(execution_time_variance)[-m:]\\n \\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job] # Perturb the execution time by adding random noise\\n \\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.76562,\n \"other_inf\": null\n }\n]" }, { "path": "docs/Results/Prob3_FSS_PGLS/run3/population_generation_9.json", "content": "[\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3154.85938,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by a combination of random selection and considering the ratio of execution times, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n execution_time_ratio = np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1)\\n random_perturb_jobs = np.random.choice(n, m // 2, replace=False)\\n ratio_based_perturb_jobs = np.argsort(execution_time_ratio)[-m // 2:]\\n \\n perturb_jobs = np.concatenate((random_perturb_jobs, ratio_based_perturb_jobs))\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.03125,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm description: The new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n perturbation_factors = np.random.uniform(0.8, 1.2, size=m).reshape(m, 1)\\n new_matrix = time_matrix.copy()\\n new_matrix[perturb_jobs] *= perturbation_factors\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.1875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm randomly selects a subset of jobs, calculates their weighted sum of execution times on different machines, and perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time, and also checks for any machine with a high utilization rate and reshuffles the jobs on that machine to balance the load.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n utilization_rate = np.sum(time_matrix, axis=0) / np.sum(time_matrix)\\n high_utilization_machines = np.where(utilization_rate > 0.8)[0]\\n \\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, min(m, n), replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n for machine in high_utilization_machines:\\n job_order = np.argsort(new_matrix[:, machine])\\n new_matrix[:, machine] = new_matrix[job_order, machine]\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.625,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their weighted sum of execution times on different machines, perturbs them in the current sequence, and updates the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.6875,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects a subset of machines, calculates their maximum execution time for each job, and perturbs the selected jobs in the current sequence to update the execution time matrix by multiplying or dividing a random perturbation factor between 0.7 and 1.3.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n machine_subset = np.random.choice(m, max(1, int(0.2*m)), replace=False)\\n max_execution_time = np.max(time_matrix[:, machine_subset], axis=1)\\n\\n perturb_jobs = np.random.choice(n, max(1, int(0.2*n)), replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.7, 1.3) * new_matrix[job, machine_subset]\\n new_matrix[job, machine_subset] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.79688,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm:\\nThe new algorithm selects the top jobs based on the ratio of maximum and minimum execution time on different machines, perturbs the selected jobs in the current sequence to update the execution time matrix by adding or subtracting a random perturbation factor multiplied by their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n ratio = (np.max(time_matrix, axis=1) / np.min(time_matrix, axis=1))\\n perturb_jobs = np.argsort(ratio)[-m:]\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n new_matrix[job] += np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.84375,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"The new algorithm selects the top jobs based on their weighted sum of execution times on different machines, perturbs them in the current sequence, and updates the execution time matrix by multiplying their execution time with a random factor between 0.8 and 1.2.\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n job_weights = np.sum(time_matrix, axis=1)\\n perturb_jobs = np.random.choice(n, m, replace=False, p=job_weights/np.sum(job_weights))\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(0.8, 1.2) * new_matrix[job]\\n new_matrix[job] = perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3155.98438,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe new algorithm selects the top jobs by random selection, perturbs them in the current sequence to update the execution time matrix by adding or subtracting a random factor to their execution time.\\n\",\n \"code\": \"import numpy as np\\n\\ndef get_matrix_and_jobs(current_sequence, time_matrix, m, n):\\n perturb_jobs = np.random.choice(n, m, replace=False)\\n\\n new_matrix = time_matrix.copy()\\n for job in perturb_jobs:\\n perturbation = np.random.uniform(-0.2, 0.2) * new_matrix[job]\\n new_matrix[job] += perturbation\\n\\n return new_matrix, perturb_jobs\",\n \"objective\": 3156.07812,\n \"other_inf\": null\n }\n]" }, { "path": "eoh/setup.py", "content": "from setuptools import setup, find_packages\n\nsetup(\n name=\"eoh\",\n version=\"0.1\",\n author=\"MetaAI Group, CityU\",\n description=\"Evolutionary Computation + Large Language Model for automatic algorithm design\",\n packages=find_packages(where='src'),\n package_dir={'': 'src'},\n python_requires=\">=3.10\",\n install_requires=[\n \"numpy\",\n \"numba\",\n \"joblib\"\n ],\n test_suite=\"tests\"\n)" }, { "path": "eoh/src/eoh/__init__.py", "content": "" }, { "path": "eoh/src/eoh/eoh.py", "content": "\nimport random\n\nfrom .utils import createFolders\nfrom .methods import methods\nfrom .problems import problems\n\n# main class for AEL\nclass EVOL:\n\n # initilization\n def __init__(self, paras, prob=None, **kwargs):\n\n print(\"----------------------------------------- \")\n print(\"--- Start EoH ---\")\n print(\"-----------------------------------------\")\n # Create folder #\n createFolders.create_folders(paras.exp_output_path)\n print(\"- output folder created -\")\n\n self.paras = paras\n\n print(\"- parameters loaded -\")\n\n self.prob = prob\n\n # Set a random seed\n random.seed(2024)\n\n \n # run methods\n def run(self):\n\n problemGenerator = problems.Probs(self.paras)\n\n problem = problemGenerator.get_problem()\n\n methodGenerator = methods.Methods(self.paras,problem)\n\n method = methodGenerator.get_method()\n\n method.run()\n\n print(\"> End of Evolution! \")\n print(\"----------------------------------------- \")\n print(\"--- EoH successfully finished ! ---\")\n print(\"-----------------------------------------\")\n" }, { "path": "eoh/src/eoh/llm/__init__.py", "content": "" }, { "path": "eoh/src/eoh/llm/api_general.py", "content": "import http.client\nimport json\n\n\nclass InterfaceAPI:\n def __init__(self, api_endpoint, api_key, model_LLM, debug_mode):\n self.api_endpoint = api_endpoint\n self.api_key = api_key\n self.model_LLM = model_LLM\n self.debug_mode = debug_mode\n self.n_trial = 5\n\n def get_response(self, prompt_content):\n payload_explanation = json.dumps(\n {\n \"model\": self.model_LLM,\n \"messages\": [\n # {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n {\"role\": \"user\", \"content\": prompt_content}\n ],\n }\n )\n\n headers = {\n \"Authorization\": \"Bearer \" + self.api_key,\n \"User-Agent\": \"Apifox/1.0.0 (https://apifox.com)\",\n \"Content-Type\": \"application/json\",\n \"x-api2d-no-cache\": 1,\n }\n \n response = None\n n_trial = 1\n while True:\n n_trial += 1\n if n_trial > self.n_trial:\n return response\n try:\n conn = http.client.HTTPSConnection(self.api_endpoint)\n conn.request(\"POST\", \"/v1/chat/completions\", payload_explanation, headers)\n res = conn.getresponse()\n data = res.read()\n json_data = json.loads(data)\n response = json_data[\"choices\"][0][\"message\"][\"content\"]\n break\n except:\n if self.debug_mode:\n print(\"Error in API. Restarting the process...\")\n continue\n \n\n return response" }, { "path": "eoh/src/eoh/llm/api_hf_inter.py", "content": "import http.client\nimport json\nimport requests\nimport torch\nclass InterfaceHF():\n\n def __init__(self,key,model_LLM,debug_mode):\n self.key = key\n self.model_LLM = model_LLM\n self.debug_mode = debug_mode\n \n def get_response(self,prompt_content):\n\n API_URL = \"https://api-inference.huggingface.co/models/\"+self.model_LLM\n headers = {\"Authorization\": f\"Bearer {self.key}\"}\n def query(payload):\n response = requests.post(API_URL, headers=headers, json=payload)\n return response.json()\n data = query(prompt_content)\n\n return data\n \n\nif __name__ == '__main__':\n key = \"XXX\"\n model = \"gpt2\"\n hf = InterfaceHF(key,model,False)\n resp = hf.get_response({\"inputs\": \"The answer to the universe is [MASK].\"})\n print(resp)\n \n # from transformers import AutoTokenizer\n # import transformers\n # model = \"meta-llama/Llama-2-7b-chat-hf\"\n \n # tokenizer = AutoTokenizer.from_pretrained(model)\n # pipeline = transformers.pipeline(\n # \"text-generation\",\n # model=model,\n # torch_dtype=torch.float16,\n # device_map=\"auto\",\n # )\n \n # sequences = pipeline(\n # 'Do you have any recommendations of other source to learn Evolving Algorithm or how to use HuggingFace I might like?\\n',\n # do_sample=True,\n # top_k=10,\n # num_return_sequences=1,\n # eos_token_id=tokenizer.eos_token_id,\n # max_length=200,\n # )\n # for seq in sequences:\n # print(f\"Result: {seq['generated_text']}\")\n\n " }, { "path": "eoh/src/eoh/llm/api_local_llm.py", "content": "# This file includes classe to get response from deployed local LLM\nimport json\nfrom typing import Collection\nimport requests\n\n\nclass InterfaceLocalLLM:\n \"\"\"Language model that predicts continuation of provided source code.\n \"\"\"\n\n def __init__(self, url):\n self._url = url # 'http://127.0.0.1:11045/completions'\n\n def get_response(self, content: str) -> str:\n while True:\n try:\n response = self._do_request(content)\n return response\n except:\n continue\n\n def _do_request(self, content: str) -> str:\n content = content.strip('\\n').strip()\n # repeat the prompt for batch inference (inorder to decease the sample delay)\n data = {\n 'prompt': content,\n 'repeat_prompt': 1,\n 'params': {\n 'do_sample': True,\n 'temperature': None,\n 'top_k': None,\n 'top_p': None,\n 'add_special_tokens': False,\n 'skip_special_tokens': True,\n }\n }\n headers = {'Content-Type': 'application/json'}\n response = requests.post(self._url, data=json.dumps(data), headers=headers)\n print(response)\n if response.status_code == 200:\n response = response.json()['content'][0]\n return response\n" }, { "path": "eoh/src/eoh/llm/interface_LLM.py", "content": "from ..llm.api_general import InterfaceAPI\nfrom ..llm.api_local_llm import InterfaceLocalLLM\n\nclass InterfaceLLM:\n def __init__(self, api_endpoint, api_key, model_LLM,llm_use_local,llm_local_url, debug_mode):\n self.api_endpoint = api_endpoint\n self.api_key = api_key\n self.model_LLM = model_LLM\n self.debug_mode = debug_mode\n self.llm_use_local = llm_use_local\n self.llm_local_url = llm_local_url\n\n print(\"- check LLM API\")\n\n if self.llm_use_local:\n print('local llm delopyment is used ...')\n \n if self.llm_local_url == None or self.llm_local_url == 'xxx' :\n print(\">> Stop with empty url for local llm !\")\n exit()\n\n self.interface_llm = InterfaceLocalLLM(\n self.llm_local_url\n )\n\n else:\n print('remote llm api is used ...')\n\n if self.api_key == None or self.api_endpoint ==None or self.api_key == 'xxx' or self.api_endpoint == 'xxx':\n print(\">> Stop with wrong API setting: Set api_endpoint (e.g., api.chat...) and api_key (e.g., kx-...) !\")\n exit()\n\n self.interface_llm = InterfaceAPI(\n self.api_endpoint,\n self.api_key,\n self.model_LLM,\n self.debug_mode,\n )\n\n \n res = self.interface_llm.get_response(\"1+1=?\")\n\n if res == None:\n print(\">> Error in LLM API, wrong endpoint, key, model or local deployment!\")\n exit()\n\n # choose LLMs\n # if self.type == \"API2D-GPT\":\n # self.interface_llm = InterfaceAPI2D(self.key,self.model_LLM,self.debug_mode)\n # else:\n # print(\">>> Wrong LLM type, only API2D-GPT is available! \\n\")\n\n def get_response(self, prompt_content):\n response = self.interface_llm.get_response(prompt_content)\n\n return response\n" }, { "path": "eoh/src/eoh/llm_local_server/codellama_instruct_server.py", "content": "import gc\nfrom argparse import ArgumentParser\nfrom threading import Thread\nfrom typing import Iterator, Optional\nimport torch\nfrom transformers import (\n AutoConfig, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n)\n\nfrom flask import Flask, request, jsonify\nfrom flask_cors import CORS\nimport json\nimport os\n\ndefault_model_path_path = '/raid/zhichao/zhangrui/LLMs/CodeLlama-7b-Instruct-hf'\n\n# arguments\nparser = ArgumentParser()\nparser.add_argument('--d', nargs='+', default=['9'])\nparser.add_argument('--quantization', default=False, action='store_true')\nparser.add_argument('--path', type=str, default=default_model_path_path)\nparser.add_argument('--host', type=str, default='127.0.0.1')\nparser.add_argument('--port', type=int, default=11012)\nargs = parser.parse_args()\n\n# cuda visible devices\ncuda_visible_devices = ','.join(args.d)\nos.environ['CUDA_VISIBLE_DEVICES'] = cuda_visible_devices\n\n# set quantization (do not quantization by default)\nif args.quantization:\n quantization_config = BitsAndBytesConfig(\n load_in_8bit=True,\n # load_in_4bit=True,\n # bnb_4bit_compute_dtype=torch.float16,\n # llm_int8_enable_fp32_cpu_offload=True\n )\nelse:\n quantization_config = None\n\n# CodeLlama-Python model\npretrained_model_path = args.path\nconfig = AutoConfig.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id,\n # cache_dir=None,\n)\n# config.pretraining_tp = 1\nmodel = AutoModelForCausalLM.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id=None,\n # config=config,\n quantization_config=quantization_config,\n device_map='auto',\n # cache_dir=None,\n # use_safetensors=False,\n)\n\n# tokenizer for the LLM\ntokenizer = AutoTokenizer.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n)\n\n# Flask API\napp = Flask(__name__)\nCORS(app)\n\n\ndef get_prompt(messages: list, system_prompt: str) -> str:\n texts = [f'[INST] <>\\n{system_prompt}\\n<>\\n\\n']\n\n do_strip = False\n for message in messages:\n messageContent = message['content'].strip() if do_strip else message['content']\n if message['role'] == 'user':\n texts.append(f'{messageContent} [/INST] ')\n else:\n texts.append(f' {messageContent.strip()} [INST] ')\n do_strip = True\n\n return ''.join(texts)\n\n\ndef format_prompt(prompt: str, sys_prompt='') -> str:\n prompt = f'''[INST] <>\n{sys_prompt}\n<>\n{prompt} \n [/INST]'''\n return prompt\n\n\n@app.route(f'/completions', methods=['POST'])\ndef completions():\n content = request.json\n prompt = content['prompt']\n prompt = format_prompt(prompt)\n repeat_prompt = content.get('repeat_prompt', 1)\n\n # due to the limitations of the GPU devices in the server, the maximum repeat prompt have to be restricted\n max_repeat_prompt = 20\n repeat_prompt = min(max_repeat_prompt, repeat_prompt)\n\n print(f'========================================== Prompt ==========================================')\n print(f'{prompt}\\n')\n print(f'============================================================================================')\n print(f'\\n\\n')\n\n max_new_tokens = 512\n temperature = None\n do_sample = True\n top_k = None\n top_p = None\n num_return_sequences = 1\n eos_token_id = 2\n pad_token_id = 2\n\n if 'params' in content:\n params: dict = content.get('params')\n max_new_tokens = params.get('max_new_tokens', max_new_tokens)\n temperature = params.get('temperature', temperature)\n do_sample = params.get('do_sample', do_sample)\n top_k = params.get('top_k', top_k)\n top_p = params.get('top_p', top_p)\n num_return_sequences = params.get('num_return_sequences', num_return_sequences)\n eos_token_id = params.get('eos_token_id', eos_token_id)\n pad_token_id = params.get('pad_token_id', pad_token_id)\n\n while True:\n # print(prompt)\n inputs = tokenizer(prompt, return_tensors='pt', add_special_tokens=False).to('cuda')\n # inputs = tokenizer.encode(prompt, return_tensors='pt').to(model.device)\n # inputs = torch.vstack([inputs] * repeat_prompt).to(model.device)\n\n try:\n # LLM inference\n output = model.generate(\n **inputs,\n max_new_tokens=max_new_tokens,\n temperature=temperature,\n do_sample=do_sample,\n top_k=top_k,\n top_p=top_p,\n num_return_sequences=num_return_sequences,\n eos_token_id=eos_token_id,\n pad_token_id=pad_token_id\n )\n except torch.cuda.OutOfMemoryError as e:\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n # decrease repeat_prompt num\n repeat_prompt = max(repeat_prompt // 2, 1)\n continue\n\n content = []\n for i, out_ in enumerate(output):\n content.append(tokenizer.decode(output[i, len(inputs[i]):], skip_special_tokens=True))\n\n print(f'======================================== Response Content ========================================')\n print(f'{content}\\n')\n print(f'==================================================================================================')\n print(f'\\n\\n')\n\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n\n # Send back the response.\n return jsonify(\n {'content': content}\n )\n\n\nif __name__ == '__main__':\n app.run(host=args.host, port=args.port, threaded=False)\n" }, { "path": "eoh/src/eoh/llm_local_server/codellama_server.py", "content": "import gc\nfrom argparse import ArgumentParser\nfrom threading import Thread\nfrom typing import Iterator, Optional\nimport torch\nfrom transformers import (\n AutoConfig, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n)\n\nfrom flask import Flask, request, jsonify\nfrom flask_cors import CORS\nimport json\nimport os\n\ndefault_model_path_path = '/raid/zhichao/zhangrui/LLMs/CodeLlama-7b-Python-hf'\n\n# arguments\nparser = ArgumentParser()\nparser.add_argument('--d', nargs='+', default=['2'])\nparser.add_argument('--quantization', default=False, action='store_true')\nparser.add_argument('--path', type=str, default=default_model_path_path)\nparser.add_argument('--host', type=str, default='127.0.0.1')\nparser.add_argument('--port', type=int, default=11012)\nargs = parser.parse_args()\n\n# cuda visible devices\ncuda_visible_devices = ','.join(args.d)\nos.environ['CUDA_VISIBLE_DEVICES'] = cuda_visible_devices\n\n# set quantization (do not quantization by default)\nif args.quantization:\n quantization_config = BitsAndBytesConfig(\n load_in_8bit=True,\n # load_in_4bit=True,\n # bnb_4bit_compute_dtype=torch.float16,\n # llm_int8_enable_fp32_cpu_offload=True\n )\nelse:\n quantization_config = None\n\n# CodeLlama-Python model\npretrained_model_path = args.path\nconfig = AutoConfig.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id,\n # cache_dir=None,\n)\n# config.pretraining_tp = 1\nmodel = AutoModelForCausalLM.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id=None,\n # config=config,\n quantization_config=quantization_config,\n device_map='auto',\n # cache_dir=None,\n # use_safetensors=False,\n)\n\n# tokenizer for the LLM\ntokenizer = AutoTokenizer.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n)\n\n# Flask API\napp = Flask(__name__)\nCORS(app)\n\n\n@app.route(f'/completions', methods=['POST'])\ndef completions():\n content = request.json\n prompt = content['prompt']\n repeat_prompt = content.get('repeat_prompt', 1)\n\n # due to the limitations of the GPU devices in the server, the maximum repeat prompt have to be restricted\n max_repeat_prompt = 20\n repeat_prompt = min(max_repeat_prompt, repeat_prompt)\n\n print(f'========================================== Prompt ==========================================')\n print(f'{prompt}\\n')\n print(f'============================================================================================')\n print(f'\\n\\n')\n\n max_new_tokens = 512\n temperature = None\n do_sample = True\n top_k = None\n top_p = None\n num_return_sequences = 1\n eos_token_id = 0\n pad_token_id = 0\n\n if 'params' in content:\n params: dict = content.get('params')\n max_new_tokens = params.get('max_new_tokens', 512)\n temperature = params.get('temperature', None)\n do_sample = params.get('do_sample', True)\n top_k = params.get('top_k', None)\n top_p = params.get('top_p', None)\n num_return_sequences = params.get('num_return_sequences', 1)\n eos_token_id = params.get('eos_token_id', 0)\n pad_token_id = params.get('pad_token_id', 0)\n\n while True:\n # print(prompt)\n prompt = prompt\n inputs = tokenizer.encode(prompt, return_tensors='pt').to(model.device)\n inputs = torch.vstack([inputs] * repeat_prompt).to(model.device)\n\n try:\n # LLM inference\n output = model.generate(\n inputs,\n max_new_tokens=max_new_tokens,\n temperature=temperature,\n do_sample=do_sample,\n top_k=top_k,\n top_p=top_p,\n num_return_sequences=num_return_sequences,\n eos_token_id=eos_token_id,\n pad_token_id=pad_token_id\n )\n except torch.cuda.OutOfMemoryError as e:\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n # decrease repeat_prompt num\n repeat_prompt = max(repeat_prompt // 2, 1)\n continue\n\n content = []\n for i, out_ in enumerate(output):\n content.append(tokenizer.decode(output[i, len(inputs[i]):], skip_special_tokens=True))\n\n print(f'======================================== Response Content ========================================')\n print(f'{content}\\n')\n print(f'==================================================================================================')\n print(f'\\n\\n')\n\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n\n # Send back the response.\n return jsonify(\n {'content': content}\n )\n\n\nif __name__ == '__main__':\n app.run(host=args.host, port=args.port, threaded=False)\n" }, { "path": "eoh/src/eoh/llm_local_server/deepseek_coder_server.py", "content": "import gc\nfrom argparse import ArgumentParser\nfrom threading import Thread\nfrom typing import Iterator, Optional\nimport torch\nfrom transformers import (\n AutoConfig, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n)\nfrom flask import Flask, request, jsonify, Response, stream_with_context\n\nfrom flask_cors import CORS\nimport json\nimport os\n\n# model_path_home = '/raid/zhichao/zhangrui/LLMs'\ndefault_model_path_path = '/raid/zhichao/zhangrui/LLMs/CodeLlama-7b-Instruct-hf'\n\n# arguments\nparser = ArgumentParser()\nparser.add_argument('--d', nargs='+', default=['1', '2', '3'])\nparser.add_argument('--quantization', default=False, action='store_true')\nparser.add_argument('--path', type=str, default=default_model_path_path)\nparser.add_argument('--host', type=str, default='127.0.0.1')\nparser.add_argument('--port', type=int, default=11011)\n\nargs = parser.parse_args()\n\n# cuda visible devices\ncuda_visible_devices = ','.join(args.d)\nos.environ['CUDA_VISIBLE_DEVICES'] = cuda_visible_devices\n\n# set quantization (do not quantization by default)\nif args.quantization:\n quantization_config = BitsAndBytesConfig(\n load_in_8bit=True,\n # load_in_4bit=True,\n # bnb_4bit_compute_dtype=torch.float16,\n # llm_int8_enable_fp32_cpu_offload=True\n )\nelse:\n quantization_config = None\n\n# CodeLlama-Python model\npretrained_model_path = args.path\nconfig = AutoConfig.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id,\n # cache_dir=None,\n)\n# config.pretraining_tp = 1\nmodel = AutoModelForCausalLM.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id=None,\n # config=config,\n quantization_config=quantization_config,\n device_map='auto',\n # cache_dir=None,\n # use_safetensors=False,\n)\n\n# tokenizer for the LLM\ntokenizer = AutoTokenizer.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n)\n\n# Flask API\napp = Flask(__name__)\nCORS(app)\n\n\n@app.route(f'/completions', methods=['POST'])\ndef completions():\n content = request.json\n prompt = content['prompt']\n prompt = [\n {'role': 'user', 'content': prompt}\n ]\n repeat_prompt = content.get('repeat_prompt', 1)\n\n # due to the limitations of the GPU devices in the server, the maximum repeat prompt have to be restricted\n max_repeat_prompt = 10\n repeat_prompt = min(max_repeat_prompt, repeat_prompt)\n\n print(f'========================================== Prompt ==========================================')\n print(f'{prompt}\\n')\n print(f'============================================================================================')\n print(f'\\n\\n')\n\n max_new_tokens = 512\n temperature = 0.3\n do_sample = True\n top_k = 30\n top_p = 0.9\n num_return_sequences = 1\n eos_token_id = 32021\n pad_token_id = 32021\n\n if 'params' in content:\n params: dict = content.get('params')\n max_new_tokens = params.get('max_new_tokens', 512)\n temperature = params.get('temperature', 0.3)\n do_sample = params.get('do_sample', True)\n top_k = params.get('top_k', 30)\n top_p = params.get('top_p', 0.9)\n num_return_sequences = params.get('num_return_sequences', 1)\n eos_token_id = params.get('eos_token_id', 32021)\n pad_token_id = params.get('pad_token_id', 32021)\n\n while True:\n inputs = tokenizer.apply_chat_template(prompt, add_generation_prompt=True, return_tensors='pt')\n inputs = torch.vstack([inputs] * repeat_prompt).to(model.device)\n\n try:\n # LLM inference\n output = model.generate(\n inputs,\n max_new_tokens=max_new_tokens,\n temperature=temperature,\n do_sample=do_sample,\n top_k=top_k,\n top_p=top_p,\n num_return_sequences=num_return_sequences,\n eos_token_id=eos_token_id,\n pad_token_id=pad_token_id\n )\n except torch.cuda.OutOfMemoryError as e:\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n # decrease repeat_prompt num\n repeat_prompt = max(repeat_prompt // 2, 1)\n continue\n\n content = []\n for i, out_ in enumerate(output):\n content.append(tokenizer.decode(output[i, len(inputs[i]):], skip_special_tokens=True))\n\n print(f'======================================== Response Content ========================================')\n print(f'{content}\\n')\n print(f'==================================================================================================')\n print(f'\\n\\n')\n\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n\n # Send back the response.\n return jsonify(\n {'content': content}\n )\n\n\nif __name__ == '__main__':\n app.run(host=args.host, port=args.port)\n" }, { "path": "eoh/src/eoh/llm_local_server/gemma_instruct_server.py", "content": "import gc\nimport os\nfrom argparse import ArgumentParser\n\nimport torch\nfrom flask import Flask, request, jsonify\nfrom flask_cors import CORS\nfrom transformers import (\n AutoConfig, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n)\n\ndefault_model_path_path = 'gemma-2b-it'\n\n# arguments\nparser = ArgumentParser()\nparser.add_argument('--d', nargs='+', default=['0'])\nparser.add_argument('--quantization', default=False, action='store_true')\nparser.add_argument('--path', type=str, default=default_model_path_path)\nparser.add_argument('--host', type=str, default='127.0.0.1')\nparser.add_argument('--port', type=int, default=11015)\nargs = parser.parse_args()\n\n# cuda visible devices\ncuda_visible_devices = ','.join(args.d)\n# os.environ['CUDA_VISIBLE_DEVICES'] = cuda_visible_devices\n\n# set quantization (do not quantization by default)\n# set quantization (do not quantization by default)\nif args.quantization:\n quantization_config = BitsAndBytesConfig(\n # load_in_8bit=True,\n load_in_4bit=True,\n bnb_4bit_compute_dtype=torch.float16,\n # llm_int8_enable_fp32_cpu_offload=True\n )\n\nelse:\n quantization_config = None\n\n# CodeLlama-Python model\npretrained_model_path = args.path\nconfig = AutoConfig.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n)\n# config.pretraining_tp = 1\nmodel = AutoModelForCausalLM.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n torch_dtype=torch.float16,\n config=config,\n quantization_config=quantization_config,\n # device_map='auto',\n)\n\n# tokenizer for the LLM\ntokenizer = AutoTokenizer.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n)\n\n# Flask API\napp = Flask(__name__)\nCORS(app)\n\n\n@app.route(f'/completions', methods=['POST'])\ndef completions():\n content = request.json\n prompt = content['prompt']\n\n # due to the limitations of the GPU devices in the server, the maximum repeat prompt have to be restricted\n max_repeat_prompt = 20\n\n print(f'========================================== Prompt ==========================================')\n print(f'{prompt}\\n')\n print(f'============================================================================================')\n print(f'\\n\\n')\n\n max_new_tokens = 512\n temperature = None\n do_sample = True\n top_k = None\n top_p = None\n\n if 'params' in content:\n params: dict = content.get('params')\n max_new_tokens = params.get('max_new_tokens', max_new_tokens)\n temperature = params.get('temperature', temperature)\n do_sample = params.get('do_sample', do_sample)\n top_k = params.get('top_k', top_k)\n top_p = params.get('top_p', top_p)\n\n while True:\n inputs = tokenizer(prompt, return_tensors='pt').to('cpu')\n\n try:\n # LLM inference\n output = model.generate(\n **inputs,\n max_new_tokens=max_new_tokens,\n temperature=temperature,\n do_sample=do_sample,\n top_k=top_k,\n top_p=top_p,\n )\n except torch.cuda.OutOfMemoryError as e:\n print(\"out of memory error\")\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n # decrease repeat_prompt num\n continue\n\n content = []\n for i, out_ in enumerate(output):\n content.append(tokenizer.decode(output[i, len(inputs[i]):], skip_special_tokens=True))\n\n print(f'======================================== Response Content ========================================')\n print(f'{content}\\n')\n print(f'==================================================================================================')\n print(f'\\n\\n')\n\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n\n # Send back the response.\n return jsonify(\n {'content': content}\n )\n\n\nif __name__ == '__main__':\n app.run(host=args.host, port=args.port, threaded=False)\n" }, { "path": "eoh/src/eoh/llm_local_server/request.py", "content": "import time\n\nimport requests\nimport json\n\nurl = 'http://127.0.0.1:11101/completions'\n\nwhile True:\n prompt = '''\ndef priority_v0(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns priority with which we want to add item to each bin.\n\n Args:\n item: Size of item to be added to the bin.\n bins: Array of capacities for each bin.\n\n Return:\n Array of same size as bins with priority score of each bin.\n \"\"\"\n penalty = np.arange(len(bins), 0, -1)\n scores = bins / (bins - item) - penalty\n max_capacity_bins = np.where(bins == bins.max())[0]\n for idx in max_capacity_bins:\n scores[idx] = -np.inf\n return scores\n\n\ndef priority_v1(item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Improved version of `priority_v0`.\"\"\"'''\n\n data = {\n 'prompt': prompt,\n 'repeat_prompt': 20,\n 'system_prompt': '',\n 'stream': False,\n 'params': {\n 'temperature': None,\n 'top_k': None,\n 'top_p': None,\n 'add_special_tokens': False,\n 'skip_special_tokens': True,\n }\n }\n\n # inputs, max_new_tokens=512, do_sample=False, top_k=50, top_p=0.95, num_return_sequences=1, eos_token_id=32021\n\n headers = {'Content-Type': 'application/json'}\n\n record_time = time.time()\n response = requests.post(url, data=json.dumps(data), headers=headers)\n durations = time.time() - record_time\n print(f'time: {durations}s')\n\n # def process_response_content(content: str) -> str:\n # ret = content.split('[/INST]')[1]\n # return ret\n\n if response.status_code == 200:\n print(f'Query time: {durations}')\n # print(f'Response: {response.json()}')\n content = response.json()[\"content\"]\n\n for c in content:\n # content = process_response_content(content)\n print(f'{c}')\n print(f'----------------------------------------------')\n else:\n print('Failed to make the POST request.')\n\n break\n" }, { "path": "eoh/src/eoh/llm_local_server/starcoder_server.py", "content": "import gc\nfrom argparse import ArgumentParser\nfrom threading import Thread\nfrom typing import Iterator, Optional\nimport torch\nfrom transformers import (\n AutoConfig, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n)\n\nfrom flask import Flask, request, jsonify\nfrom flask_cors import CORS\nimport json\nimport os\n\ndefault_model_path_path = '/raid/zhichao/zhangrui/LLMs/starcoder'\n\n# arguments\nparser = ArgumentParser()\nparser.add_argument('--d', nargs='+', default=['1', '2', '3'])\nparser.add_argument('--quantization', default=False, action='store_true')\nparser.add_argument('--path', type=str, default=default_model_path_path)\nparser.add_argument('--host', type=str, default='127.0.0.1')\nparser.add_argument('--port', type=int, default=11011)\nargs = parser.parse_args()\n\n# cuda visible devices\ncuda_visible_devices = ','.join(args.d)\nos.environ['CUDA_VISIBLE_DEVICES'] = cuda_visible_devices\n\n# set quantization (do not quantization by default)\nif args.quantization:\n quantization_config = BitsAndBytesConfig(\n load_in_8bit=True,\n # load_in_4bit=True,\n # bnb_4bit_compute_dtype=torch.float16,\n # llm_int8_enable_fp32_cpu_offload=True\n )\nelse:\n quantization_config = None\n\n# CodeLlama-Python model\npretrained_model_path = args.path\nconfig = AutoConfig.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id,\n # cache_dir=None,\n)\n# config.pretraining_tp = 1\nmodel = AutoModelForCausalLM.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n # model_id=None,\n # config=config,\n quantization_config=quantization_config,\n device_map='auto',\n # cache_dir=None,\n # use_safetensors=False,\n)\n\n# tokenizer for the LLM\ntokenizer = AutoTokenizer.from_pretrained(\n pretrained_model_name_or_path=pretrained_model_path,\n)\n\n# Flask API\napp = Flask(__name__)\nCORS(app)\n\n\n@app.route(f'/completions', methods=['POST'])\ndef completions():\n content = request.json\n prompt = content['prompt']\n repeat_prompt = content.get('repeat_prompt', 1)\n\n # due to the limitations of the GPU devices in the server, the maximum repeat prompt have to be restricted\n max_repeat_prompt = 20\n repeat_prompt = min(max_repeat_prompt, repeat_prompt)\n\n print(f'========================================== Prompt ==========================================')\n print(f'{prompt}\\n')\n print(f'============================================================================================')\n print(f'\\n\\n')\n\n max_new_tokens = 512\n temperature = None\n do_sample = True\n top_k = None\n top_p = None\n num_return_sequences = 1\n eos_token_id = 0\n pad_token_id = 0\n\n if 'params' in content:\n params: dict = content.get('params')\n max_new_tokens = params.get('max_new_tokens', 512)\n temperature = params.get('temperature', None)\n do_sample = params.get('do_sample', True)\n top_k = params.get('top_k', None)\n top_p = params.get('top_p', None)\n num_return_sequences = params.get('num_return_sequences', 1)\n eos_token_id = params.get('eos_token_id', 0)\n pad_token_id = params.get('pad_token_id', 0)\n\n while True:\n # print(prompt)\n prompt = prompt\n inputs = tokenizer.encode(prompt, return_tensors='pt').to(model.device)\n inputs = torch.vstack([inputs] * repeat_prompt).to(model.device)\n\n try:\n # LLM inference\n output = model.generate(\n inputs,\n max_new_tokens=max_new_tokens,\n temperature=temperature,\n do_sample=do_sample,\n top_k=top_k,\n top_p=top_p,\n num_return_sequences=num_return_sequences,\n eos_token_id=eos_token_id,\n pad_token_id=pad_token_id\n )\n except torch.cuda.OutOfMemoryError as e:\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n # decrease repeat_prompt num\n repeat_prompt = max(repeat_prompt // 2, 1)\n continue\n\n content = []\n for i, out_ in enumerate(output):\n content.append(tokenizer.decode(output[i, len(inputs[i]):], skip_special_tokens=True))\n\n print(f'======================================== Response Content ========================================')\n print(f'{content}\\n')\n print(f'==================================================================================================')\n print(f'\\n\\n')\n\n # clear cache\n gc.collect()\n if torch.cuda.device_count() > 0:\n torch.cuda.empty_cache()\n\n # Send back the response.\n return jsonify(\n {'content': content}\n )\n\n\nif __name__ == '__main__':\n app.run(host=args.host, port=args.port, threaded=False)\n" }, { "path": "eoh/src/eoh/methods/__init__.py", "content": "" }, { "path": "eoh/src/eoh/methods/ael/__init__.py", "content": "" }, { "path": "eoh/src/eoh/methods/ael/ael.py", "content": "import numpy as np\nimport json\nimport random\nimport time\n\nfrom .ael_interface_EC import InterfaceEC\n# main class for AEL\nclass AEL:\n\n # initilization\n def __init__(self, paras, problem, select, manage, **kwargs):\n\n self.prob = problem\n self.select = select\n self.manage = manage\n \n # LLM settings\n self.use_local_llm = paras.llm_use_local\n self.url = paras.llm_local_url\n self.api_endpoint = paras.llm_api_endpoint # currently only API2D + GPT\n self.api_key = paras.llm_api_key\n self.llm_model = paras.llm_model\n\n # ------------------ RZ: use local LLM ------------------\n self.use_local_llm = kwargs.get('use_local_llm', False)\n assert isinstance(self.use_local_llm, bool)\n if self.use_local_llm:\n assert 'url' in kwargs, 'The keyword \"url\" should be provided when use_local_llm is True.'\n assert isinstance(kwargs.get('url'), str)\n self.url = kwargs.get('url')\n # -------------------------------------------------------\n\n # Experimental settings \n self.pop_size = paras.ec_pop_size # popopulation size, i.e., the number of algorithms in population\n self.n_pop = paras.ec_n_pop # number of populations\n\n self.operators = paras.ec_operators\n self.operator_weights = paras.ec_operator_weights\n if paras.ec_m > self.pop_size or paras.ec_m == 1:\n print(\"m should not be larger than pop size or smaller than 2, adjust it to m=2\")\n paras.ec_m = 2\n self.m = paras.ec_m\n\n self.debug_mode = paras.exp_debug_mode # if debug\n self.ndelay = 1 # default\n\n self.use_seed = paras.exp_use_seed\n self.seed_path = paras.exp_seed_path\n self.load_pop = paras.exp_use_continue\n self.load_pop_path = paras.exp_continue_path\n self.load_pop_id = paras.exp_continue_id\n\n self.output_path = paras.exp_output_path\n\n self.exp_n_proc = paras.exp_n_proc\n self.timeout = paras.eva_timeout\n self.use_numba = paras.eva_numba_decorator\n print(\"- AEL parameters loaded -\")\n\n # Set a random seed\n random.seed(2024)\n\n # add new individual to population\n def add2pop(self, population, offspring):\n for off in offspring:\n for ind in population:\n if ind['objective'] == off['objective']:\n if (self.debug_mode):\n print(\"duplicated result, retrying ... \")\n population.append(off)\n \n\n # run ael \n def run(self):\n\n print(\"- Evolution Start -\")\n\n time_start = time.time()\n\n # interface for large language model (llm)\n # interface_llm = PromptLLMs(self.api_endpoint,self.api_key,self.llm_model,self.debug_mode)\n\n # interface for evaluation\n interface_prob = self.prob\n\n # interface for ec operators\n interface_ec = InterfaceEC(self.pop_size, self.m, self.api_endpoint, self.api_key, self.llm_model,\n self.debug_mode, interface_prob, use_local_llm=self.use_local_llm, url=self.url, select=self.select,n_p=self.exp_n_proc,timeout=self.timeout,use_numba=self.use_numba\n )\n\n # initialization\n population = []\n if self.use_seed:\n with open(self.seed_path) as file:\n data = json.load(file)\n population = interface_ec.population_generation_seed(data)\n filename = self.output_path + \"/results/pops/population_generation_0.json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n n_start = 0\n else:\n if self.load_pop: # load population from files\n print(\"load initial population from \" + self.load_pop_path)\n with open(self.load_pop_path) as file:\n data = json.load(file)\n for individual in data:\n population.append(individual)\n print(\"initial population has been loaded!\")\n n_start = self.load_pop_id\n else: # create new population\n print(\"creating initial population:\")\n population = interface_ec.population_generation()\n population = self.manage.population_management(population, self.pop_size)\n \n \n print(f\"Pop initial: \")\n for off in population:\n print(\" Obj: \", off['objective'], end=\"|\")\n print()\n print(\"initial population has been created!\")\n # Save population to a file\n filename = self.output_path + \"/results/pops/population_generation_0.json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n n_start = 0\n\n # main loop\n n_op = len(self.operators)\n\n for pop in range(n_start, self.n_pop): \n #print(f\" [{na + 1} / {self.pop_size}] \", end=\"|\") \n for i in range(n_op):\n op = self.operators[i]\n print(f\" OP: {op}, [{i + 1} / {n_op}] \", end=\"|\") \n op_w = self.operator_weights[i]\n if (np.random.rand() < op_w):\n parents, offsprings = interface_ec.get_algorithm(population, op)\n self.add2pop(population, offsprings) # Check duplication, and add the new offspring\n for off in offsprings:\n print(\" Obj: \", off['objective'], end=\"|\")\n # if is_add:\n # data = {}\n # for i in range(len(parents)):\n # data[f\"parent{i + 1}\"] = parents[i]\n # data[\"offspring\"] = offspring\n # with open(self.output_path + \"/results/history/pop_\" + str(pop + 1) + \"_\" + str(\n # na) + \"_\" + op + \".json\", \"w\") as file:\n # json.dump(data, file, indent=5)\n # populatin management\n size_act = min(len(population), self.pop_size)\n population = self.manage.population_management(population, size_act)\n print()\n\n\n # Save population to a file\n filename = self.output_path + \"/results/pops/population_generation_\" + str(pop + 1) + \".json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n\n # Save the best one to a file\n filename = self.output_path + \"/results/pops_best/population_generation_\" + str(pop + 1) + \".json\"\n with open(filename, 'w') as f:\n json.dump(population[0], f, indent=5)\n\n\n print(f\"--- {pop + 1} of {self.n_pop} populations finished. Time Cost: {((time.time()-time_start)/60):.1f} m\")\n print(\"Pop Objs: \", end=\" \")\n for i in range(len(population)):\n print(str(population[i]['objective']) + \" \", end=\"\")\n print()\n\n" }, { "path": "eoh/src/eoh/methods/ael/ael_evolution.py", "content": "import re\nimport time\nfrom ...llm.interface_LLM import InterfaceLLM\n\nclass Evolution():\n\n def __init__(self, api_endpoint, api_key, model_LLM, debug_mode,prompts, **kwargs):\n # -------------------- RZ: use local LLM --------------------\n assert 'use_local_llm' in kwargs\n assert 'url' in kwargs\n self._use_local_llm = kwargs.get('use_local_llm')\n self._url = kwargs.get('url')\n # -----------------------------------------------------------\n\n # set prompt interface\n #getprompts = GetPrompts()\n self.prompt_task = prompts.get_task()\n self.prompt_func_name = prompts.get_func_name()\n self.prompt_func_inputs = prompts.get_func_inputs()\n self.prompt_func_outputs = prompts.get_func_outputs()\n self.prompt_inout_inf = prompts.get_inout_inf()\n self.prompt_other_inf = prompts.get_other_inf()\n if len(self.prompt_func_inputs) > 1:\n self.joined_inputs = \", \".join(\"'\" + s + \"'\" for s in self.prompt_func_inputs)\n else:\n self.joined_inputs = \"'\" + self.prompt_func_inputs[0] + \"'\"\n\n if len(self.prompt_func_outputs) > 1:\n self.joined_outputs = \", \".join(\"'\" + s + \"'\" for s in self.prompt_func_outputs)\n else:\n self.joined_outputs = \"'\" + self.prompt_func_outputs[0] + \"'\"\n\n # set LLMs\n self.api_endpoint = api_endpoint\n self.api_key = api_key\n self.model_LLM = model_LLM\n self.debug_mode = debug_mode # close prompt checking\n\n # -------------------- RZ: use local LLM --------------------\n if self._use_local_llm:\n self.interface_llm = LocalLLM(self._url)\n else:\n self.interface_llm = InterfaceLLM(self.api_endpoint, self.api_key, self.model_LLM, self.debug_mode)\n\n def get_prompt_i1(self):\n \n prompt_content = self.prompt_task+\"\\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n\n \n def get_prompt_crossover(self,indivs):\n prompt_indiv = \"\"\n for i in range(len(indivs)):\n prompt_indiv=prompt_indiv+\"No.\"+str(i+1) +\" algorithm and the corresponding code are: \\n\" + indivs[i]['algorithm']+\"\\n\" +indivs[i]['code']+\"\\n\"\n\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have \"+str(len(indivs))+\" existing algorithms with their codes as follows: \\n\"\\\n+prompt_indiv+\\\n\"Please help me create a new algorithm that has different form from the given ones but can be motivated by them. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n\n def get_prompt_mutation(self,indiv1):\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have one algorithm with its code as follows. \\\nAlgorithm description: \"+indiv1['algorithm']+\"\\n\\\nCode:\\n\\\n\"+indiv1['code']+\"\\n\\\nPlease assist me in creating a new algorithm that is a modified version of the algorithm provided. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n\n\n def _get_alg(self,prompt_content):\n\n response = self.interface_llm.get_response(prompt_content)\n\n algorithm = re.findall(r\"\\{(.*)\\}\", response, re.DOTALL)\n if len(algorithm) == 0:\n if 'python' in response:\n algorithm = re.findall(r'^.*?(?=python)', response,re.DOTALL)\n elif 'import' in response:\n algorithm = re.findall(r'^.*?(?=import)', response,re.DOTALL)\n else:\n algorithm = re.findall(r'^.*?(?=def)', response,re.DOTALL)\n\n code = re.findall(r\"import.*return\", response, re.DOTALL)\n if len(code) == 0:\n code = re.findall(r\"def.*return\", response, re.DOTALL)\n\n n_retry = 1\n while (len(algorithm) == 0 or len(code) == 0):\n if self.debug_mode:\n print(\"Error: algorithm or code not identified, wait 1 seconds and retrying ... \")\n\n response = self.interface_llm.get_response(prompt_content)\n\n algorithm = re.findall(r\"\\{(.*)\\}\", response, re.DOTALL)\n if len(algorithm) == 0:\n if 'python' in response:\n algorithm = re.findall(r'^.*?(?=python)', response,re.DOTALL)\n elif 'import' in response:\n algorithm = re.findall(r'^.*?(?=import)', response,re.DOTALL)\n else:\n algorithm = re.findall(r'^.*?(?=def)', response,re.DOTALL)\n\n code = re.findall(r\"import.*return\", response, re.DOTALL)\n if len(code) == 0:\n code = re.findall(r\"def.*return\", response, re.DOTALL)\n \n if n_retry > 3:\n break\n n_retry +=1\n\n algorithm = algorithm[0]\n code = code[0] \n\n code_all = code+\" \"+\", \".join(s for s in self.prompt_func_outputs) \n\n\n return [code_all, algorithm]\n\n\n def i1(self):\n\n prompt_content = self.get_prompt_i1()\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ i1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def crossover(self,parents):\n \n prompt_content = self.get_prompt_crossover(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ e1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n\n \n def mutation(self,parents):\n \n prompt_content = self.get_prompt_mutation(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ m1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n" }, { "path": "eoh/src/eoh/methods/ael/ael_interface_EC.py", "content": "import numpy as np\nimport time\nfrom .ael_evolution import Evolution\nimport warnings\nfrom joblib import Parallel, delayed\nfrom .evaluator_accelerate import add_numba_decorator\nimport re\nimport concurrent.futures\n\nclass InterfaceEC():\n def __init__(self, pop_size, m, api_endpoint, api_key, llm_model, debug_mode, interface_prob, select,n_p,timeout,use_numba, **kwargs):\n # -------------------- RZ: use local LLM --------------------\n assert 'use_local_llm' in kwargs\n assert 'url' in kwargs\n # -----------------------------------------------------------\n\n # LLM settings\n self.pop_size = pop_size\n self.interface_eval = interface_prob\n prompts = interface_prob.prompts\n self.evol = Evolution(api_endpoint, api_key, llm_model, debug_mode,prompts, **kwargs)\n self.m = m\n self.debug = debug_mode\n\n if not self.debug:\n warnings.filterwarnings(\"ignore\")\n\n self.select = select\n self.n_p = n_p\n self.timeout = timeout\n self.use_numba = use_numba\n \n def code2file(self,code):\n with open(\"./ael_alg.py\", \"w\") as file:\n # Write the code to the file\n file.write(code)\n return \n \n def add2pop(self,population,offspring):\n for ind in population:\n if ind['objective'] == offspring['objective']:\n if self.debug:\n print(\"duplicated result, retrying ... \")\n return False\n population.append(offspring)\n return True\n \n def check_duplicate(self,population,code):\n for ind in population:\n if code == ind['code']:\n return True\n return False\n\n # def population_management(self,pop):\n # # Delete the worst individual\n # pop_new = heapq.nsmallest(self.pop_size, pop, key=lambda x: x['objective'])\n # return pop_new\n \n # def parent_selection(self,pop,m):\n # ranks = [i for i in range(len(pop))]\n # probs = [1 / (rank + 1 + len(pop)) for rank in ranks]\n # parents = random.choices(pop, weights=probs, k=m)\n # return parents\n\n def population_generation(self):\n \n n_create = 2\n \n population = []\n\n for i in range(n_create):\n _,pop = self.get_algorithm([],'i1')\n for p in pop:\n population.append(p)\n return population\n \n def population_generation_seed(self,seeds,n_p):\n\n population = []\n\n fitness = Parallel(n_jobs=n_p)(delayed(self.interface_eval.evaluate)(seed['code']) for seed in seeds)\n\n for i in range(len(seeds)):\n try:\n seed_alg = {\n 'algorithm': seeds[i]['algorithm'],\n 'code': seeds[i]['code'],\n 'objective': None,\n 'other_inf': None\n }\n\n obj = np.array(fitness[i])\n seed_alg['objective'] = np.round(obj, 5)\n population.append(seed_alg)\n\n except Exception as e:\n print(\"Error in seed algorithm\")\n exit()\n\n print(\"Initiliazation finished! Get \"+str(len(seeds))+\" seed algorithms\")\n\n return population\n \n\n def _get_alg(self,pop,operator):\n offspring = {\n 'algorithm': None,\n 'code': None,\n 'objective': None,\n 'other_inf': None\n }\n if operator == \"i1\":\n parents = None\n [offspring['code'],offspring['algorithm']] = self.evol.i1() \n elif operator == \"crossover\":\n parents = self.select.parent_selection(pop,self.m)\n [offspring['code'],offspring['algorithm']] = self.evol.crossover(parents)\n elif operator == \"mutation\":\n parents = self.select.parent_selection(pop,1)\n [offspring['code'],offspring['algorithm']] = self.evol.mutation(parents[0]) \n else:\n print(f\"Evolution operator [{operator}] has not been implemented ! \\n\") \n\n return parents, offspring\n\n def get_offspring(self, pop, operator):\n\n try:\n p, offspring = self._get_alg(pop, operator)\n \n if self.use_numba:\n \n # Regular expression pattern to match function definitions\n pattern = r\"def\\s+(\\w+)\\s*\\(.*\\):\"\n\n # Search for function definitions in the code\n match = re.search(pattern, offspring['code'])\n\n function_name = match.group(1)\n\n code = add_numba_decorator(program=offspring['code'], function_name=function_name)\n else:\n code = offspring['code']\n\n n_retry= 1\n while self.check_duplicate(pop, offspring['code']):\n \n n_retry += 1\n if self.debug:\n print(\"duplicated code, wait 1 second and retrying ... \")\n \n p, offspring = self._get_alg(pop, operator)\n\n if self.use_numba:\n # Regular expression pattern to match function definitions\n pattern = r\"def\\s+(\\w+)\\s*\\(.*\\):\"\n\n # Search for function definitions in the code\n match = re.search(pattern, offspring['code'])\n\n function_name = match.group(1)\n\n code = add_numba_decorator(program=offspring['code'], function_name=function_name)\n else:\n code = offspring['code']\n \n if n_retry > 1:\n break\n \n \n #self.code2file(offspring['code'])\n with concurrent.futures.ThreadPoolExecutor() as executor:\n future = executor.submit(self.interface_eval.evaluate, code)\n fitness = future.result(timeout=self.timeout)\n offspring['objective'] = np.round(fitness, 5)\n future.cancel()\n \n # fitness = self.interface_eval.evaluate(code)\n \n\n except Exception as e:\n\n offspring = {\n 'algorithm': None,\n 'code': None,\n 'objective': None,\n 'other_inf': None\n }\n p = None\n\n # Round the objective values\n return p, offspring\n\n # def process_task(self,pop, operator):\n # result = None, {\n # 'algorithm': None,\n # 'code': None,\n # 'objective': None,\n # 'other_inf': None\n # }\n # with concurrent.futures.ThreadPoolExecutor() as executor:\n # future = executor.submit(self.get_offspring, pop, operator)\n # try:\n # result = future.result(timeout=self.timeout)\n # future.cancel()\n # #print(result)\n # except:\n # future.cancel()\n \n # return result\n\n \n def get_algorithm(self, pop, operator):\n\n results = []\n try:\n results = Parallel(n_jobs=self.n_p,timeout=self.timeout+15)(delayed(self.get_offspring)(pop, operator) for _ in range(self.pop_size))\n except:\n print(\"Parallel time out .\")\n \n time.sleep(2)\n\n out_p = []\n out_off = []\n\n for p, off in results:\n out_p.append(p)\n out_off.append(off)\n return out_p, out_off\n # def get_algorithm(self,pop,operator, pop_size, n_p):\n \n # # perform it pop_size times with n_p processes in parallel\n # p,offspring = self._get_alg(pop,operator)\n # while self.check_duplicate(pop,offspring['code']):\n # if self.debug:\n # print(\"duplicated code, wait 1 second and retrying ... \")\n # time.sleep(1)\n # p,offspring = self._get_alg(pop,operator)\n # self.code2file(offspring['code'])\n # try:\n # fitness= self.interface_eval.evaluate()\n # except:\n # fitness = None\n # offspring['objective'] = fitness\n # #offspring['other_inf'] = first_gap\n # while (fitness == None):\n # if self.debug:\n # print(\"warning! error code, retrying ... \")\n # p,offspring = self._get_alg(pop,operator)\n # while self.check_duplicate(pop,offspring['code']):\n # if self.debug:\n # print(\"duplicated code, wait 1 second and retrying ... \")\n # time.sleep(1)\n # p,offspring = self._get_alg(pop,operator)\n # self.code2file(offspring['code'])\n # try:\n # fitness= self.interface_eval.evaluate()\n # except:\n # fitness = None\n # offspring['objective'] = fitness\n # #offspring['other_inf'] = first_gap\n # offspring['objective'] = np.round(offspring['objective'],5) \n # #offspring['other_inf'] = np.round(offspring['other_inf'],3)\n # return p,offspring\n" }, { "path": "eoh/src/eoh/methods/ael/evaluator_accelerate.py", "content": "# This file is implemented by RZ.\n# This file aims to accelerate the original evaluate logic using 'numba' package.\n# You should install numba package in your Python environment or the later evaluation will fail.\nfrom __future__ import annotations\n\nimport ast\nfrom typing import Sequence, Tuple\n\n\ndef add_import_package_statement(program: str, package_name: str, as_name=None, *, check_imported=True) -> str:\n \"\"\"Add 'import package_name as as_name' in the program code.\n \"\"\"\n tree = ast.parse(program)\n if check_imported:\n # check if 'import package_name' code exists\n package_imported = False\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == package_name for alias in node.names):\n package_imported = True\n break\n\n if package_imported:\n return ast.unparse(tree)\n\n # add 'import package_name' to the top of the program\n import_node = ast.Import(names=[ast.alias(name=package_name, asname=as_name)])\n tree.body.insert(0, import_node)\n program = ast.unparse(tree)\n return programe\n\n\ndef _add_numba_decorator(\n program: str,\n function_name: str\n) -> str:\n # parse to syntax tree\n tree = ast.parse(program)\n\n # check if 'import numba' already exists\n numba_imported = False\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == 'numba' for alias in node.names):\n numba_imported = True\n break\n\n # add 'import numba' to the top of the program\n if not numba_imported:\n import_node = ast.Import(names=[ast.alias(name='numba', asname=None)])\n tree.body.insert(0, import_node)\n\n # traverse the tree, and find the function_to_run\n for node in ast.walk(tree):\n if isinstance(node, ast.FunctionDef) and node.name == function_name:\n # the '@numba.jit()' decorator instance\n decorator = ast.Call(\n func=ast.Attribute(\n value=ast.Name(id='numba', ctx=ast.Load()),\n attr='jit',\n ctx=ast.Load()\n ),\n args=[], # args do not have argument name\n keywords=[ast.keyword(arg='nopython', value=ast.NameConstant(value=True))]\n # keywords have argument name\n )\n # add the decorator to the decorator_list of the node\n node.decorator_list.append(decorator)\n\n # turn the tree to string and return\n modified_program = ast.unparse(tree)\n return modified_program\n\n\ndef add_numba_decorator(\n program: str,\n function_name: str | Sequence[str],\n) -> str:\n \"\"\"\n This function aims to accelerate the evaluation of the searched code. This is achieved by decorating '@numba.jit()'\n to the function_to_evolve or other functions in the specification that can be speed up using numba.\n However, it should be noted that not all numpy functions support numba acceleration: such as np.piecewise().\n So use this function wisely. Hahaha!\n\n Example input program:\n def func(a: np.ndarray):\n return a * 2\n Example output program\n import numba\n\n numba.jit()\n def func(a: np.ndarray):\n return a * 2\n \"\"\"\n if isinstance(function_name, str):\n return _add_numba_decorator(program, function_name)\n for f_name in function_name:\n program = _add_numba_decorator(program, f_name)\n return program\n\n\ndef add_np_random_seed_below_numpy_import(program: str, seed: int = 2024) -> str:\n \"\"\"Add 'import numpy as np' statement (if needed) to the program and insert 'np.random.seed(seed)' under it.\n Args:\n program: program you want to add.\n seed: seed number.\n Returns:\n modified_code: program with 'np.random.seed(...)'.\n \"\"\"\n program = add_import_package_statement(program, 'numpy', 'np')\n tree = ast.parse(program)\n\n # find 'import numpy as np'\n found_numpy_import = False\n\n # find 'import numpy as np' statement\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == 'numpy' and alias.asname == 'np' for alias in node.names):\n found_numpy_import = True\n # insert new node\n node_idx = tree.body.index(node)\n seed_node = ast.Expr(\n value=ast.Call(\n func=ast.Attribute(\n value=ast.Attribute(\n value=ast.Name(id='np', ctx=ast.Load()),\n attr='random',\n ctx=ast.Load()\n ),\n attr='seed',\n ctx=ast.Load()\n ),\n args=[ast.Num(n=seed)],\n keywords=[]\n )\n )\n tree.body.insert(node_idx + 1, seed_node)\n\n if not found_numpy_import:\n raise ValueError(\"No 'import numpy as np' found in the code.\")\n\n modified_code = ast.unparse(tree)\n return modified_code\n\n\nclass _CustomDivisionTransformer(ast.NodeTransformer):\n def __init__(self, custom_divide_func_name: str):\n super().__init__()\n self._custom_div_func = custom_divide_func_name\n\n def visit_BinOp(self, node):\n self.generic_visit(node) # recur visit child nodes\n if isinstance(node.op, ast.Div):\n # self-defined node\n custom_divide_call = ast.Call(\n func=ast.Name(id=self._custom_div_func, ctx=ast.Load()),\n args=[node.left, node.right],\n keywords=[]\n )\n return custom_divide_call\n return node\n\n\ndef replace_div_with_protected_div(code_str: str, delta=1e-5, numba_accelerate=False) -> Tuple[str, str]:\n # protected_div_str = f'_protected_div = lambda x, y, delta={delta}: x / (y + delta) if y == 0 else x / y'\n protected_div_str = f'''\ndef _protected_div(x, y, delta={delta}):\n return x / (y + delta)\n '''\n tree = ast.parse(code_str)\n transformer = _CustomDivisionTransformer('_protected_div')\n modified_tree = transformer.visit(tree)\n modified_code = ast.unparse(modified_tree)\n modified_code = '\\n'.join([modified_code, '', '', protected_div_str])\n if numba_accelerate:\n modified_code = add_numba_decorator(modified_code, '_protected_div')\n return modified_code, '_protected_div'\n\n\ndef add_numpy_random_seed_to_func(program: str, func_name: str, seed: int = 2024) -> str:\n tree = ast.parse(program)\n\n for node in tree.body:\n if isinstance(node, ast.FunctionDef) and node.name == func_name:\n node.body = [ast.parse(f'np.random.seed({seed})').body[0]] + node.body\n\n modified_code = ast.unparse(tree)\n return modified_code\n\n\n\nif __name__ == '__main__':\n code = '''\nimport numpy as np\n\ndef hello():\n return 'xxx'\n\n\ndef func(a, b, c):\n return a + b - c\n '''\n\n output = add_numba_decorator(program=code, function_name='func')\n print(output)\n" }, { "path": "eoh/src/eoh/methods/eoh/__init__.py", "content": "" }, { "path": "eoh/src/eoh/methods/eoh/eoh.py", "content": "import numpy as np\nimport json\nimport random\nimport time\n\nfrom .eoh_interface_EC import InterfaceEC\n# main class for eoh\nclass EOH:\n\n # initilization\n def __init__(self, paras, problem, select, manage, **kwargs):\n\n self.prob = problem\n self.select = select\n self.manage = manage\n \n # LLM settings\n self.use_local_llm = paras.llm_use_local\n self.llm_local_url = paras.llm_local_url\n self.api_endpoint = paras.llm_api_endpoint # currently only API2D + GPT\n self.api_key = paras.llm_api_key\n self.llm_model = paras.llm_model\n\n # ------------------ RZ: use local LLM ------------------\n # self.use_local_llm = kwargs.get('use_local_llm', False)\n # assert isinstance(self.use_local_llm, bool)\n # if self.use_local_llm:\n # assert 'url' in kwargs, 'The keyword \"url\" should be provided when use_local_llm is True.'\n # assert isinstance(kwargs.get('url'), str)\n # self.url = kwargs.get('url')\n # -------------------------------------------------------\n\n # Experimental settings \n self.pop_size = paras.ec_pop_size # popopulation size, i.e., the number of algorithms in population\n self.n_pop = paras.ec_n_pop # number of populations\n\n self.operators = paras.ec_operators\n self.operator_weights = paras.ec_operator_weights\n if paras.ec_m > self.pop_size or paras.ec_m == 1:\n print(\"m should not be larger than pop size or smaller than 2, adjust it to m=2\")\n paras.ec_m = 2\n self.m = paras.ec_m\n\n self.debug_mode = paras.exp_debug_mode # if debug\n self.ndelay = 1 # default\n\n self.use_seed = paras.exp_use_seed\n self.seed_path = paras.exp_seed_path\n self.load_pop = paras.exp_use_continue\n self.load_pop_path = paras.exp_continue_path\n self.load_pop_id = paras.exp_continue_id\n\n self.output_path = paras.exp_output_path\n\n self.exp_n_proc = paras.exp_n_proc\n \n self.timeout = paras.eva_timeout\n\n self.use_numba = paras.eva_numba_decorator\n\n print(\"- EoH parameters loaded -\")\n\n # Set a random seed\n random.seed(2024)\n\n # add new individual to population\n def add2pop(self, population, offspring):\n for off in offspring:\n for ind in population:\n if ind['objective'] == off['objective']:\n if (self.debug_mode):\n print(\"duplicated result, retrying ... \")\n population.append(off)\n \n\n # run eoh \n def run(self):\n\n print(\"- Evolution Start -\")\n\n time_start = time.time()\n\n # interface for large language model (llm)\n # interface_llm = PromptLLMs(self.api_endpoint,self.api_key,self.llm_model,self.debug_mode)\n\n # interface for evaluation\n interface_prob = self.prob\n\n # interface for ec operators\n interface_ec = InterfaceEC(self.pop_size, self.m, self.api_endpoint, self.api_key, self.llm_model, self.use_local_llm, self.llm_local_url,\n self.debug_mode, interface_prob, select=self.select,n_p=self.exp_n_proc,\n timeout = self.timeout, use_numba=self.use_numba\n )\n\n # initialization\n population = []\n if self.use_seed:\n with open(self.seed_path) as file:\n data = json.load(file)\n population = interface_ec.population_generation_seed(data,self.exp_n_proc)\n filename = self.output_path + \"/results/pops/population_generation_0.json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n n_start = 0\n else:\n if self.load_pop: # load population from files\n print(\"load initial population from \" + self.load_pop_path)\n with open(self.load_pop_path) as file:\n data = json.load(file)\n for individual in data:\n population.append(individual)\n print(\"initial population has been loaded!\")\n n_start = self.load_pop_id\n else: # create new population\n print(\"creating initial population:\")\n population = interface_ec.population_generation()\n population = self.manage.population_management(population, self.pop_size)\n\n # print(len(population))\n # if len(population)= self.pop_size:\n # break\n # print(len(population))\n \n \n print(f\"Pop initial: \")\n for off in population:\n print(\" Obj: \", off['objective'], end=\"|\")\n print()\n print(\"initial population has been created!\")\n # Save population to a file\n filename = self.output_path + \"/results/pops/population_generation_0.json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n n_start = 0\n\n # main loop\n n_op = len(self.operators)\n\n for pop in range(n_start, self.n_pop): \n #print(f\" [{na + 1} / {self.pop_size}] \", end=\"|\") \n for i in range(n_op):\n op = self.operators[i]\n print(f\" OP: {op}, [{i + 1} / {n_op}] \", end=\"|\") \n op_w = self.operator_weights[i]\n if (np.random.rand() < op_w):\n parents, offsprings = interface_ec.get_algorithm(population, op)\n self.add2pop(population, offsprings) # Check duplication, and add the new offspring\n for off in offsprings:\n print(\" Obj: \", off['objective'], end=\"|\")\n # if is_add:\n # data = {}\n # for i in range(len(parents)):\n # data[f\"parent{i + 1}\"] = parents[i]\n # data[\"offspring\"] = offspring\n # with open(self.output_path + \"/results/history/pop_\" + str(pop + 1) + \"_\" + str(\n # na) + \"_\" + op + \".json\", \"w\") as file:\n # json.dump(data, file, indent=5)\n # populatin management\n size_act = min(len(population), self.pop_size)\n population = self.manage.population_management(population, size_act)\n print()\n\n\n # Save population to a file\n filename = self.output_path + \"/results/pops/population_generation_\" + str(pop + 1) + \".json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n\n # Save the best one to a file\n filename = self.output_path + \"/results/pops_best/population_generation_\" + str(pop + 1) + \".json\"\n with open(filename, 'w') as f:\n json.dump(population[0], f, indent=5)\n\n\n print(f\"--- {pop + 1} of {self.n_pop} populations finished. Time Cost: {((time.time()-time_start)/60):.1f} m\")\n print(\"Pop Objs: \", end=\" \")\n for i in range(len(population)):\n print(str(population[i]['objective']) + \" \", end=\"\")\n print()\n\n" }, { "path": "eoh/src/eoh/methods/eoh/eoh_evolution.py", "content": "import re\nimport time\nfrom ...llm.interface_LLM import InterfaceLLM\n\nclass Evolution():\n\n def __init__(self, api_endpoint, api_key, model_LLM,llm_use_local,llm_local_url, debug_mode,prompts, **kwargs):\n\n # set prompt interface\n #getprompts = GetPrompts()\n self.prompt_task = prompts.get_task()\n self.prompt_func_name = prompts.get_func_name()\n self.prompt_func_inputs = prompts.get_func_inputs()\n self.prompt_func_outputs = prompts.get_func_outputs()\n self.prompt_inout_inf = prompts.get_inout_inf()\n self.prompt_other_inf = prompts.get_other_inf()\n if len(self.prompt_func_inputs) > 1:\n self.joined_inputs = \", \".join(\"'\" + s + \"'\" for s in self.prompt_func_inputs)\n else:\n self.joined_inputs = \"'\" + self.prompt_func_inputs[0] + \"'\"\n\n if len(self.prompt_func_outputs) > 1:\n self.joined_outputs = \", \".join(\"'\" + s + \"'\" for s in self.prompt_func_outputs)\n else:\n self.joined_outputs = \"'\" + self.prompt_func_outputs[0] + \"'\"\n\n # set LLMs\n self.api_endpoint = api_endpoint\n self.api_key = api_key\n self.model_LLM = model_LLM\n self.debug_mode = debug_mode # close prompt checking\n\n\n self.interface_llm = InterfaceLLM(self.api_endpoint, self.api_key, self.model_LLM,llm_use_local,llm_local_url, self.debug_mode)\n\n def get_prompt_i1(self):\n \n prompt_content = self.prompt_task+\"\\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n\n \n def get_prompt_e1(self,indivs):\n prompt_indiv = \"\"\n for i in range(len(indivs)):\n prompt_indiv=prompt_indiv+\"No.\"+str(i+1) +\" algorithm and the corresponding code are: \\n\" + indivs[i]['algorithm']+\"\\n\" +indivs[i]['code']+\"\\n\"\n\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have \"+str(len(indivs))+\" existing algorithms with their codes as follows: \\n\"\\\n+prompt_indiv+\\\n\"Please help me create a new algorithm that has a totally different form from the given ones. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n def get_prompt_e2(self,indivs):\n prompt_indiv = \"\"\n for i in range(len(indivs)):\n prompt_indiv=prompt_indiv+\"No.\"+str(i+1) +\" algorithm and the corresponding code are: \\n\" + indivs[i]['algorithm']+\"\\n\" +indivs[i]['code']+\"\\n\"\n\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have \"+str(len(indivs))+\" existing algorithms with their codes as follows: \\n\"\\\n+prompt_indiv+\\\n\"Please help me create a new algorithm that has a totally different form from the given ones but can be motivated from them. \\n\"\\\n\"Firstly, identify the common backbone idea in the provided algorithms. Secondly, based on the backbone idea describe your new algorithm in one sentence. \\\nThe description must be inside a brace. Thirdly, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n def get_prompt_m1(self,indiv1):\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have one algorithm with its code as follows. \\\nAlgorithm description: \"+indiv1['algorithm']+\"\\n\\\nCode:\\n\\\n\"+indiv1['code']+\"\\n\\\nPlease assist me in creating a new algorithm that has a different form but can be a modified version of the algorithm provided. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n def get_prompt_m2(self,indiv1):\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have one algorithm with its code as follows. \\\nAlgorithm description: \"+indiv1['algorithm']+\"\\n\\\nCode:\\n\\\n\"+indiv1['code']+\"\\n\\\nPlease identify the main algorithm parameters and assist me in creating a new algorithm that has a different parameter settings of the score function provided. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n def get_prompt_m3(self,indiv1):\n prompt_content = \"First, you need to identify the main components in the function below. \\\nNext, analyze whether any of these components can be overfit to the in-distribution instances. \\\nThen, based on your analysis, simplify the components to enhance the generalization to potential out-of-distribution instances. \\\nFinally, provide the revised code, keeping the function name, inputs, and outputs unchanged. \\n\"+indiv1['code']+\"\\n\"\\\n+self.prompt_inout_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n\n\n def _get_alg(self,prompt_content):\n\n response = self.interface_llm.get_response(prompt_content)\n\n algorithm = re.findall(r\"\\{(.*)\\}\", response, re.DOTALL)\n if len(algorithm) == 0:\n if 'python' in response:\n algorithm = re.findall(r'^.*?(?=python)', response,re.DOTALL)\n elif 'import' in response:\n algorithm = re.findall(r'^.*?(?=import)', response,re.DOTALL)\n else:\n algorithm = re.findall(r'^.*?(?=def)', response,re.DOTALL)\n\n code = re.findall(r\"import.*return\", response, re.DOTALL)\n if len(code) == 0:\n code = re.findall(r\"def.*return\", response, re.DOTALL)\n\n n_retry = 1\n while (len(algorithm) == 0 or len(code) == 0):\n if self.debug_mode:\n print(\"Error: algorithm or code not identified, wait 1 seconds and retrying ... \")\n\n response = self.interface_llm.get_response(prompt_content)\n\n algorithm = re.findall(r\"\\{(.*)\\}\", response, re.DOTALL)\n if len(algorithm) == 0:\n if 'python' in response:\n algorithm = re.findall(r'^.*?(?=python)', response,re.DOTALL)\n elif 'import' in response:\n algorithm = re.findall(r'^.*?(?=import)', response,re.DOTALL)\n else:\n algorithm = re.findall(r'^.*?(?=def)', response,re.DOTALL)\n\n code = re.findall(r\"import.*return\", response, re.DOTALL)\n if len(code) == 0:\n code = re.findall(r\"def.*return\", response, re.DOTALL)\n \n if n_retry > 3:\n break\n n_retry +=1\n\n algorithm = algorithm[0]\n code = code[0] \n\n code_all = code+\" \"+\", \".join(s for s in self.prompt_func_outputs) \n\n\n return [code_all, algorithm]\n\n\n def i1(self):\n\n prompt_content = self.get_prompt_i1()\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ i1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def e1(self,parents):\n \n prompt_content = self.get_prompt_e1(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ e1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def e2(self,parents):\n \n prompt_content = self.get_prompt_e2(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ e2 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def m1(self,parents):\n \n prompt_content = self.get_prompt_m1(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ m1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def m2(self,parents):\n \n prompt_content = self.get_prompt_m2(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ m2 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def m3(self,parents):\n \n prompt_content = self.get_prompt_m3(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ m3 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]" }, { "path": "eoh/src/eoh/methods/eoh/eoh_interface_EC.py", "content": "import numpy as np\nimport time\nfrom .eoh_evolution import Evolution\nimport warnings\nfrom joblib import Parallel, delayed\nfrom .evaluator_accelerate import add_numba_decorator\nimport re\nimport concurrent.futures\n\nclass InterfaceEC():\n def __init__(self, pop_size, m, api_endpoint, api_key, llm_model,llm_use_local,llm_local_url, debug_mode, interface_prob, select,n_p,timeout,use_numba,**kwargs):\n\n # LLM settings\n self.pop_size = pop_size\n self.interface_eval = interface_prob\n prompts = interface_prob.prompts\n self.evol = Evolution(api_endpoint, api_key, llm_model,llm_use_local,llm_local_url, debug_mode,prompts, **kwargs)\n self.m = m\n self.debug = debug_mode\n\n if not self.debug:\n warnings.filterwarnings(\"ignore\")\n\n self.select = select\n self.n_p = n_p\n \n self.timeout = timeout\n self.use_numba = use_numba\n \n def code2file(self,code):\n with open(\"./ael_alg.py\", \"w\") as file:\n # Write the code to the file\n file.write(code)\n return \n \n def add2pop(self,population,offspring):\n for ind in population:\n if ind['objective'] == offspring['objective']:\n if self.debug:\n print(\"duplicated result, retrying ... \")\n return False\n population.append(offspring)\n return True\n \n def check_duplicate(self,population,code):\n for ind in population:\n if code == ind['code']:\n return True\n return False\n\n # def population_management(self,pop):\n # # Delete the worst individual\n # pop_new = heapq.nsmallest(self.pop_size, pop, key=lambda x: x['objective'])\n # return pop_new\n \n # def parent_selection(self,pop,m):\n # ranks = [i for i in range(len(pop))]\n # probs = [1 / (rank + 1 + len(pop)) for rank in ranks]\n # parents = random.choices(pop, weights=probs, k=m)\n # return parents\n\n def population_generation(self):\n \n n_create = 2\n \n population = []\n\n for i in range(n_create):\n _,pop = self.get_algorithm([],'i1')\n for p in pop:\n population.append(p)\n \n return population\n \n def population_generation_seed(self,seeds,n_p):\n\n population = []\n\n fitness = Parallel(n_jobs=n_p)(delayed(self.interface_eval.evaluate)(seed['code']) for seed in seeds)\n\n for i in range(len(seeds)):\n try:\n seed_alg = {\n 'algorithm': seeds[i]['algorithm'],\n 'code': seeds[i]['code'],\n 'objective': None,\n 'other_inf': None\n }\n\n obj = np.array(fitness[i])\n seed_alg['objective'] = np.round(obj, 5)\n population.append(seed_alg)\n\n except Exception as e:\n print(\"Error in seed algorithm\")\n exit()\n\n print(\"Initiliazation finished! Get \"+str(len(seeds))+\" seed algorithms\")\n\n return population\n \n\n def _get_alg(self,pop,operator):\n offspring = {\n 'algorithm': None,\n 'code': None,\n 'objective': None,\n 'other_inf': None\n }\n if operator == \"i1\":\n parents = None\n [offspring['code'],offspring['algorithm']] = self.evol.i1() \n elif operator == \"e1\":\n parents = self.select.parent_selection(pop,self.m)\n [offspring['code'],offspring['algorithm']] = self.evol.e1(parents)\n elif operator == \"e2\":\n parents = self.select.parent_selection(pop,self.m)\n [offspring['code'],offspring['algorithm']] = self.evol.e2(parents) \n elif operator == \"m1\":\n parents = self.select.parent_selection(pop,1)\n [offspring['code'],offspring['algorithm']] = self.evol.m1(parents[0]) \n elif operator == \"m2\":\n parents = self.select.parent_selection(pop,1)\n [offspring['code'],offspring['algorithm']] = self.evol.m2(parents[0]) \n elif operator == \"m3\":\n parents = self.select.parent_selection(pop,1)\n [offspring['code'],offspring['algorithm']] = self.evol.m3(parents[0]) \n else:\n print(f\"Evolution operator [{operator}] has not been implemented ! \\n\") \n\n return parents, offspring\n\n def get_offspring(self, pop, operator):\n\n try:\n p, offspring = self._get_alg(pop, operator)\n \n if self.use_numba:\n \n # Regular expression pattern to match function definitions\n pattern = r\"def\\s+(\\w+)\\s*\\(.*\\):\"\n\n # Search for function definitions in the code\n match = re.search(pattern, offspring['code'])\n\n function_name = match.group(1)\n\n code = add_numba_decorator(program=offspring['code'], function_name=function_name)\n else:\n code = offspring['code']\n\n n_retry= 1\n while self.check_duplicate(pop, offspring['code']):\n \n n_retry += 1\n if self.debug:\n print(\"duplicated code, wait 1 second and retrying ... \")\n \n p, offspring = self._get_alg(pop, operator)\n\n if self.use_numba:\n # Regular expression pattern to match function definitions\n pattern = r\"def\\s+(\\w+)\\s*\\(.*\\):\"\n\n # Search for function definitions in the code\n match = re.search(pattern, offspring['code'])\n\n function_name = match.group(1)\n\n code = add_numba_decorator(program=offspring['code'], function_name=function_name)\n else:\n code = offspring['code']\n \n if n_retry > 1:\n break\n \n \n #self.code2file(offspring['code'])\n with concurrent.futures.ThreadPoolExecutor() as executor:\n future = executor.submit(self.interface_eval.evaluate, code)\n fitness = future.result(timeout=self.timeout)\n offspring['objective'] = np.round(fitness, 5)\n future.cancel() \n # fitness = self.interface_eval.evaluate(code)\n \n\n except Exception as e:\n\n offspring = {\n 'algorithm': None,\n 'code': None,\n 'objective': None,\n 'other_inf': None\n }\n p = None\n\n # Round the objective values\n return p, offspring\n # def process_task(self,pop, operator):\n # result = None, {\n # 'algorithm': None,\n # 'code': None,\n # 'objective': None,\n # 'other_inf': None\n # }\n # with concurrent.futures.ThreadPoolExecutor() as executor:\n # future = executor.submit(self.get_offspring, pop, operator)\n # try:\n # result = future.result(timeout=self.timeout)\n # future.cancel()\n # #print(result)\n # except:\n # future.cancel()\n \n # return result\n\n \n def get_algorithm(self, pop, operator):\n results = []\n try:\n results = Parallel(n_jobs=self.n_p,timeout=self.timeout+15)(delayed(self.get_offspring)(pop, operator) for _ in range(self.pop_size))\n except Exception as e:\n if self.debug:\n print(f\"Error: {e}\")\n print(\"Parallel time out .\")\n \n time.sleep(2)\n\n\n out_p = []\n out_off = []\n\n for p, off in results:\n out_p.append(p)\n out_off.append(off)\n if self.debug:\n print(f\">>> check offsprings: \\n {off}\")\n return out_p, out_off\n # def get_algorithm(self,pop,operator, pop_size, n_p):\n \n # # perform it pop_size times with n_p processes in parallel\n # p,offspring = self._get_alg(pop,operator)\n # while self.check_duplicate(pop,offspring['code']):\n # if self.debug:\n # print(\"duplicated code, wait 1 second and retrying ... \")\n # time.sleep(1)\n # p,offspring = self._get_alg(pop,operator)\n # self.code2file(offspring['code'])\n # try:\n # fitness= self.interface_eval.evaluate()\n # except:\n # fitness = None\n # offspring['objective'] = fitness\n # #offspring['other_inf'] = first_gap\n # while (fitness == None):\n # if self.debug:\n # print(\"warning! error code, retrying ... \")\n # p,offspring = self._get_alg(pop,operator)\n # while self.check_duplicate(pop,offspring['code']):\n # if self.debug:\n # print(\"duplicated code, wait 1 second and retrying ... \")\n # time.sleep(1)\n # p,offspring = self._get_alg(pop,operator)\n # self.code2file(offspring['code'])\n # try:\n # fitness= self.interface_eval.evaluate()\n # except:\n # fitness = None\n # offspring['objective'] = fitness\n # #offspring['other_inf'] = first_gap\n # offspring['objective'] = np.round(offspring['objective'],5) \n # #offspring['other_inf'] = np.round(offspring['other_inf'],3)\n # return p,offspring\n" }, { "path": "eoh/src/eoh/methods/eoh/evaluator_accelerate.py", "content": "# This file is implemented by RZ.\n# This file aims to accelerate the original evaluate logic using 'numba' package.\n# You should install numba package in your Python environment or the later evaluation will fail.\nfrom __future__ import annotations\n\nimport ast\nfrom typing import Sequence, Tuple\n\n\ndef add_import_package_statement(program: str, package_name: str, as_name=None, *, check_imported=True) -> str:\n \"\"\"Add 'import package_name as as_name' in the program code.\n \"\"\"\n tree = ast.parse(program)\n if check_imported:\n # check if 'import package_name' code exists\n package_imported = False\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == package_name for alias in node.names):\n package_imported = True\n break\n\n if package_imported:\n return ast.unparse(tree)\n\n # add 'import package_name' to the top of the program\n import_node = ast.Import(names=[ast.alias(name=package_name, asname=as_name)])\n tree.body.insert(0, import_node)\n program = ast.unparse(tree)\n return program\n\n\ndef _add_numba_decorator(\n program: str,\n function_name: str\n) -> str:\n # parse to syntax tree\n tree = ast.parse(program)\n\n # check if 'import numba' already exists\n numba_imported = False\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == 'numba' for alias in node.names):\n numba_imported = True\n break\n\n # add 'import numba' to the top of the program\n if not numba_imported:\n import_node = ast.Import(names=[ast.alias(name='numba', asname=None)])\n tree.body.insert(0, import_node)\n\n # traverse the tree, and find the function_to_run\n for node in ast.walk(tree):\n if isinstance(node, ast.FunctionDef) and node.name == function_name:\n # the '@numba.jit()' decorator instance\n decorator = ast.Call(\n func=ast.Attribute(\n value=ast.Name(id='numba', ctx=ast.Load()),\n attr='jit',\n ctx=ast.Load()\n ),\n args=[], # args do not have argument name\n keywords=[ast.keyword(arg='nopython', value=ast.NameConstant(value=True))]\n # keywords have argument name\n )\n # add the decorator to the decorator_list of the node\n node.decorator_list.append(decorator)\n\n # turn the tree to string and return\n modified_program = ast.unparse(tree)\n return modified_program\n\n\ndef add_numba_decorator(\n program: str,\n function_name: str | Sequence[str],\n) -> str:\n \"\"\"\n This function aims to accelerate the evaluation of the searched code. This is achieved by decorating '@numba.jit()'\n to the function_to_evolve or other functions in the specification that can be speed up using numba.\n However, it should be noted that not all numpy functions support numba acceleration: such as np.piecewise().\n So use this function wisely. Hahaha!\n\n Example input program:\n def func(a: np.ndarray):\n return a * 2\n Example output program\n import numba\n\n numba.jit()\n def func(a: np.ndarray):\n return a * 2\n \"\"\"\n if isinstance(function_name, str):\n return _add_numba_decorator(program, function_name)\n for f_name in function_name:\n program = _add_numba_decorator(program, f_name)\n return program\n\n\ndef add_np_random_seed_below_numpy_import(program: str, seed: int = 2024) -> str:\n \"\"\"Add 'import numpy as np' statement (if needed) to the program and insert 'np.random.seed(seed)' under it.\n Args:\n program: program you want to add.\n seed: seed number.\n Returns:\n modified_code: program with 'np.random.seed(...)'.\n \"\"\"\n program = add_import_package_statement(program, 'numpy', 'np')\n tree = ast.parse(program)\n\n # find 'import numpy as np'\n found_numpy_import = False\n\n # find 'import numpy as np' statement\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == 'numpy' and alias.asname == 'np' for alias in node.names):\n found_numpy_import = True\n # insert new node\n node_idx = tree.body.index(node)\n seed_node = ast.Expr(\n value=ast.Call(\n func=ast.Attribute(\n value=ast.Attribute(\n value=ast.Name(id='np', ctx=ast.Load()),\n attr='random',\n ctx=ast.Load()\n ),\n attr='seed',\n ctx=ast.Load()\n ),\n args=[ast.Num(n=seed)],\n keywords=[]\n )\n )\n tree.body.insert(node_idx + 1, seed_node)\n\n if not found_numpy_import:\n raise ValueError(\"No 'import numpy as np' found in the code.\")\n\n modified_code = ast.unparse(tree)\n return modified_code\n\n\nclass _CustomDivisionTransformer(ast.NodeTransformer):\n def __init__(self, custom_divide_func_name: str):\n super().__init__()\n self._custom_div_func = custom_divide_func_name\n\n def visit_BinOp(self, node):\n self.generic_visit(node) # recur visit child nodes\n if isinstance(node.op, ast.Div):\n # self-defined node\n custom_divide_call = ast.Call(\n func=ast.Name(id=self._custom_div_func, ctx=ast.Load()),\n args=[node.left, node.right],\n keywords=[]\n )\n return custom_divide_call\n return node\n\n\ndef replace_div_with_protected_div(code_str: str, delta=1e-5, numba_accelerate=False) -> Tuple[str, str]:\n # protected_div_str = f'_protected_div = lambda x, y, delta={delta}: x / (y + delta) if y == 0 else x / y'\n protected_div_str = f'''\ndef _protected_div(x, y, delta={delta}):\n return x / (y + delta)\n '''\n tree = ast.parse(code_str)\n transformer = _CustomDivisionTransformer('_protected_div')\n modified_tree = transformer.visit(tree)\n modified_code = ast.unparse(modified_tree)\n modified_code = '\\n'.join([modified_code, '', '', protected_div_str])\n if numba_accelerate:\n modified_code = add_numba_decorator(modified_code, '_protected_div')\n return modified_code, '_protected_div'\n\n\ndef add_numpy_random_seed_to_func(program: str, func_name: str, seed: int = 2024) -> str:\n tree = ast.parse(program)\n\n for node in tree.body:\n if isinstance(node, ast.FunctionDef) and node.name == func_name:\n node.body = [ast.parse(f'np.random.seed({seed})').body[0]] + node.body\n\n modified_code = ast.unparse(tree)\n return modified_code\n\n\n\nif __name__ == '__main__':\n code = '''\nimport numpy as np\n\ndef hello():\n return 'xxx'\n\n\ndef func(a, b, c):\n return a + b - c\n '''\n\n output = add_numba_decorator(program=code, function_name='func')\n print(output)\n" }, { "path": "eoh/src/eoh/methods/localsearch/__init__.py", "content": "" }, { "path": "eoh/src/eoh/methods/localsearch/evaluator_accelerate.py", "content": "# This file is implemented by RZ.\n# This file aims to accelerate the original evaluate logic using 'numba' package.\n# You should install numba package in your Python environment or the later evaluation will fail.\nfrom __future__ import annotations\n\nimport ast\nfrom typing import Sequence, Tuple\n\n\ndef add_import_package_statement(program: str, package_name: str, as_name=None, *, check_imported=True) -> str:\n \"\"\"Add 'import package_name as as_name' in the program code.\n \"\"\"\n tree = ast.parse(program)\n if check_imported:\n # check if 'import package_name' code exists\n package_imported = False\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == package_name for alias in node.names):\n package_imported = True\n break\n\n if package_imported:\n return ast.unparse(tree)\n\n # add 'import package_name' to the top of the program\n import_node = ast.Import(names=[ast.alias(name=package_name, asname=as_name)])\n tree.body.insert(0, import_node)\n program = ast.unparse(tree)\n return programe\n\n\ndef _add_numba_decorator(\n program: str,\n function_name: str\n) -> str:\n # parse to syntax tree\n tree = ast.parse(program)\n\n # check if 'import numba' already exists\n numba_imported = False\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == 'numba' for alias in node.names):\n numba_imported = True\n break\n\n # add 'import numba' to the top of the program\n if not numba_imported:\n import_node = ast.Import(names=[ast.alias(name='numba', asname=None)])\n tree.body.insert(0, import_node)\n\n # traverse the tree, and find the function_to_run\n for node in ast.walk(tree):\n if isinstance(node, ast.FunctionDef) and node.name == function_name:\n # the '@numba.jit()' decorator instance\n decorator = ast.Call(\n func=ast.Attribute(\n value=ast.Name(id='numba', ctx=ast.Load()),\n attr='jit',\n ctx=ast.Load()\n ),\n args=[], # args do not have argument name\n keywords=[ast.keyword(arg='nopython', value=ast.NameConstant(value=True))]\n # keywords have argument name\n )\n # add the decorator to the decorator_list of the node\n node.decorator_list.append(decorator)\n\n # turn the tree to string and return\n modified_program = ast.unparse(tree)\n return modified_program\n\n\ndef add_numba_decorator(\n program: str,\n function_name: str | Sequence[str],\n) -> str:\n \"\"\"\n This function aims to accelerate the evaluation of the searched code. This is achieved by decorating '@numba.jit()'\n to the function_to_evolve or other functions in the specification that can be speed up using numba.\n However, it should be noted that not all numpy functions support numba acceleration: such as np.piecewise().\n So use this function wisely. Hahaha!\n\n Example input program:\n def func(a: np.ndarray):\n return a * 2\n Example output program\n import numba\n\n numba.jit()\n def func(a: np.ndarray):\n return a * 2\n \"\"\"\n if isinstance(function_name, str):\n return _add_numba_decorator(program, function_name)\n for f_name in function_name:\n program = _add_numba_decorator(program, f_name)\n return program\n\n\ndef add_np_random_seed_below_numpy_import(program: str, seed: int = 2024) -> str:\n \"\"\"Add 'import numpy as np' statement (if needed) to the program and insert 'np.random.seed(seed)' under it.\n Args:\n program: program you want to add.\n seed: seed number.\n Returns:\n modified_code: program with 'np.random.seed(...)'.\n \"\"\"\n program = add_import_package_statement(program, 'numpy', 'np')\n tree = ast.parse(program)\n\n # find 'import numpy as np'\n found_numpy_import = False\n\n # find 'import numpy as np' statement\n for node in tree.body:\n if isinstance(node, ast.Import) and any(alias.name == 'numpy' and alias.asname == 'np' for alias in node.names):\n found_numpy_import = True\n # insert new node\n node_idx = tree.body.index(node)\n seed_node = ast.Expr(\n value=ast.Call(\n func=ast.Attribute(\n value=ast.Attribute(\n value=ast.Name(id='np', ctx=ast.Load()),\n attr='random',\n ctx=ast.Load()\n ),\n attr='seed',\n ctx=ast.Load()\n ),\n args=[ast.Num(n=seed)],\n keywords=[]\n )\n )\n tree.body.insert(node_idx + 1, seed_node)\n\n if not found_numpy_import:\n raise ValueError(\"No 'import numpy as np' found in the code.\")\n\n modified_code = ast.unparse(tree)\n return modified_code\n\n\nclass _CustomDivisionTransformer(ast.NodeTransformer):\n def __init__(self, custom_divide_func_name: str):\n super().__init__()\n self._custom_div_func = custom_divide_func_name\n\n def visit_BinOp(self, node):\n self.generic_visit(node) # recur visit child nodes\n if isinstance(node.op, ast.Div):\n # self-defined node\n custom_divide_call = ast.Call(\n func=ast.Name(id=self._custom_div_func, ctx=ast.Load()),\n args=[node.left, node.right],\n keywords=[]\n )\n return custom_divide_call\n return node\n\n\ndef replace_div_with_protected_div(code_str: str, delta=1e-5, numba_accelerate=False) -> Tuple[str, str]:\n # protected_div_str = f'_protected_div = lambda x, y, delta={delta}: x / (y + delta) if y == 0 else x / y'\n protected_div_str = f'''\ndef _protected_div(x, y, delta={delta}):\n return x / (y + delta)\n '''\n tree = ast.parse(code_str)\n transformer = _CustomDivisionTransformer('_protected_div')\n modified_tree = transformer.visit(tree)\n modified_code = ast.unparse(modified_tree)\n modified_code = '\\n'.join([modified_code, '', '', protected_div_str])\n if numba_accelerate:\n modified_code = add_numba_decorator(modified_code, '_protected_div')\n return modified_code, '_protected_div'\n\n\ndef add_numpy_random_seed_to_func(program: str, func_name: str, seed: int = 2024) -> str:\n tree = ast.parse(program)\n\n for node in tree.body:\n if isinstance(node, ast.FunctionDef) and node.name == func_name:\n node.body = [ast.parse(f'np.random.seed({seed})').body[0]] + node.body\n\n modified_code = ast.unparse(tree)\n return modified_code\n\n\n\nif __name__ == '__main__':\n code = '''\nimport numpy as np\n\ndef hello():\n return 'xxx'\n\n\ndef func(a, b, c):\n return a + b - c\n '''\n\n output = add_numba_decorator(program=code, function_name='func')\n print(output)\n" }, { "path": "eoh/src/eoh/methods/localsearch/ls.py", "content": "import numpy as np\nimport json\nimport random\nimport time\n\nfrom .ls_interface_EC import InterfaceEC\n# main class for Local Search\nclass LS:\n\n # initilization\n def __init__(self, paras, problem, select, manage, **kwargs):\n\n self.prob = problem\n self.select = select\n self.manage = manage\n \n # LLM settings\n self.use_local_llm = paras.llm_use_local\n self.url = paras.llm_local_url\n self.api_endpoint = paras.llm_api_endpoint # currently only API2D + GPT\n self.api_key = paras.llm_api_key\n self.llm_model = paras.llm_model\n\n # ------------------ RZ: use local LLM ------------------\n self.use_local_llm = kwargs.get('use_local_llm', False)\n assert isinstance(self.use_local_llm, bool)\n if self.use_local_llm:\n assert 'url' in kwargs, 'The keyword \"url\" should be provided when use_local_llm is True.'\n assert isinstance(kwargs.get('url'), str)\n self.url = kwargs.get('url')\n # -------------------------------------------------------\n\n # Experimental settings \n self.pop_size = paras.ec_pop_size # popopulation size, i.e., the number of algorithms in population\n self.n_pop = paras.ec_n_pop # number of populations\n\n self.operators = paras.ec_operators\n self.operator_weights = paras.ec_operator_weights\n if paras.ec_m > self.pop_size or paras.ec_m == 1:\n print(\"m should not be larger than pop size or smaller than 2, adjust it to m=2\")\n paras.ec_m = 2\n self.m = paras.ec_m\n\n self.debug_mode = paras.exp_debug_mode # if debug\n self.ndelay = 1 # default\n\n self.use_seed = paras.exp_use_seed\n self.seed_path = paras.exp_seed_path\n self.load_pop = paras.exp_use_continue\n self.load_pop_path = paras.exp_continue_path\n self.load_pop_id = paras.exp_continue_id\n\n self.output_path = paras.exp_output_path\n\n self.exp_n_proc = paras.exp_n_proc\n\n print(\"- LS parameters loaded -\")\n\n # Set a random seed\n random.seed(2024)\n\n # add new individual to population\n def add2pop(self, population, offspring):\n for off in offspring:\n for ind in population:\n if ind['objective'] == off['objective']:\n if (self.debug_mode):\n print(\"duplicated result, retrying ... \")\n population.append(off)\n \n\n # run ls\n def run(self):\n\n print(\"- Evolution Start -\")\n\n time_start = time.time()\n\n # interface for large language model (llm)\n # interface_llm = PromptLLMs(self.api_endpoint,self.api_key,self.llm_model,self.debug_mode)\n\n # interface for evaluation\n interface_prob = self.prob\n\n # interface for ec operators\n interface_ec = InterfaceEC(self.pop_size, self.m, self.api_endpoint, self.api_key, self.llm_model,\n self.debug_mode, interface_prob, use_local_llm=self.use_local_llm, url=self.url, select=self.select,n_p=self.exp_n_proc\n )\n\n # initialization\n population = []\n if self.use_seed:\n with open(self.seed_path) as file:\n data = json.load(file)\n population = interface_ec.population_generation_seed(data)\n filename = self.output_path + \"/results/pops/population_generation_0.json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n n_start = 0\n else:\n if self.load_pop: # load population from files\n print(\"load initial population from \" + self.load_pop_path)\n with open(self.load_pop_path) as file:\n data = json.load(file)\n for individual in data:\n population.append(individual)\n print(\"initial population has been loaded!\")\n n_start = self.load_pop_id\n else: # create new population\n print(\"creating initial population:\")\n population = interface_ec.population_generation()\n \n #population = self.manage.population_management(population, self.pop_size, 0.5)\n \n \n print(f\"Pop initial: \")\n for off in population:\n print(\" Obj: \", off['objective'], end=\"|\")\n print()\n print(\"initial population has been created!\")\n # Save population to a file\n filename = self.output_path + \"/results/pops/population_generation_0.json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n n_start = 0\n\n # main loop\n n_op = len(self.operators)\n\n for pop in range(n_start, self.n_pop): \n \n temperature = 0.5*(1 - (pop+1)/self.n_pop)\n \n #print(f\" [{na + 1} / {self.pop_size}] \", end=\"|\") \n for i in range(n_op):\n op = self.operators[i]\n print(f\" OP: {op}, [{i + 1} / {n_op}] \", end=\"|\") \n op_w = self.operator_weights[i]\n if (np.random.rand() < op_w):\n parents, offsprings = interface_ec.get_algorithm(population, op)\n \n self.manage.population_management(population,offsprings[0],temperature)\n\n # Save population to a file\n filename = self.output_path + \"/results/pops/population_generation_\" + str(pop + 1) + \".json\"\n with open(filename, 'w') as f:\n json.dump(population, f, indent=5)\n\n # Save the best one to a file\n filename = self.output_path + \"/results/pops_best/population_generation_\" + str(pop + 1) + \".json\"\n with open(filename, 'w') as f:\n json.dump(population[0], f, indent=5)\n\n\n print(f\"--- {pop + 1} of {self.n_pop} populations finished. Time Cost: {((time.time()-time_start)/60):.1f} m\")\n print(\"Pop Objs: \", end=\" \")\n for i in range(len(population)):\n print(str(population[i]['objective']) + \" \", end=\"\")\n print()\n\n" }, { "path": "eoh/src/eoh/methods/localsearch/ls_evolution.py", "content": "import re\nimport time\nfrom ...llm.interface_LLM import InterfaceLLM\n\nclass Evolution():\n\n def __init__(self, api_endpoint, api_key, model_LLM, debug_mode,prompts, **kwargs):\n # -------------------- RZ: use local LLM --------------------\n assert 'use_local_llm' in kwargs\n assert 'url' in kwargs\n self._use_local_llm = kwargs.get('use_local_llm')\n self._url = kwargs.get('url')\n # -----------------------------------------------------------\n\n # set prompt interface\n #getprompts = GetPrompts()\n self.prompt_task = prompts.get_func_name()\n self.prompt_func_name = prompts.get_func_name()\n self.prompt_func_inputs = prompts.get_func_inputs()\n self.prompt_func_outputs = prompts.get_func_outputs()\n self.prompt_inout_inf = prompts.get_inout_inf()\n self.prompt_other_inf = prompts.get_other_inf()\n if len(self.prompt_func_inputs) > 1:\n self.joined_inputs = \", \".join(\"'\" + s + \"'\" for s in self.prompt_func_inputs)\n else:\n self.joined_inputs = \"'\" + self.prompt_func_inputs[0] + \"'\"\n\n if len(self.prompt_func_outputs) > 1:\n self.joined_outputs = \", \".join(\"'\" + s + \"'\" for s in self.prompt_func_outputs)\n else:\n self.joined_outputs = \"'\" + self.prompt_func_outputs[0] + \"'\"\n\n # set LLMs\n self.api_endpoint = api_endpoint\n self.api_key = api_key\n self.model_LLM = model_LLM\n self.debug_mode = debug_mode # close prompt checking\n\n # -------------------- RZ: use local LLM --------------------\n if self._use_local_llm:\n self.interface_llm = LocalLLM(self._url)\n else:\n self.interface_llm = InterfaceLLM(self.api_endpoint, self.api_key, self.model_LLM, self.debug_mode)\n\n def get_prompt_i1(self):\n \n prompt_content = self.prompt_task+\"\\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n\n \n def get_prompt_e1(self,indivs):\n prompt_indiv = \"\"\n for i in range(len(indivs)):\n prompt_indiv=prompt_indiv+\"No.\"+str(i+1) +\" algorithm and the corresponding code are: \\n\" + indivs[i]['algorithm']+\"\\n\" +indivs[i]['code']+\"\\n\"\n\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have \"+str(len(indivs))+\" existing algorithms with their codes as follows: \\n\"\\\n+prompt_indiv+\\\n\"Please help me create a new algorithm that has a totally different form from the given ones. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n def get_prompt_e2(self,indivs):\n prompt_indiv = \"\"\n for i in range(len(indivs)):\n prompt_indiv=prompt_indiv+\"No.\"+str(i+1) +\" algorithm and the corresponding code are: \\n\" + indivs[i]['algorithm']+\"\\n\" +indivs[i]['code']+\"\\n\"\n\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have \"+str(len(indivs))+\" existing algorithms with their codes as follows: \\n\"\\\n+prompt_indiv+\\\n\"Please help me create a new algorithm that has a totally different form from the given ones but can be motivated from them. \\n\"\\\n\"Firstly, identify the common backbone idea in the provided algorithms. Secondly, based on the backbone idea describe your new algorithm in one sentence. \\\nThe description must be inside a brace. Thirdly, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n def get_prompt_m1(self,indiv1):\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have one algorithm with its code as follows. \\\nAlgorithm description: \"+indiv1['algorithm']+\"\\n\\\nCode:\\n\\\n\"+indiv1['code']+\"\\n\\\nPlease assist me in creating a new algorithm that has a different form but can be a modified version of the algorithm provided. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n \n def get_prompt_m2(self,indiv1):\n prompt_content = self.prompt_task+\"\\n\"\\\n\"I have one algorithm with its code as follows. \\\nAlgorithm description: \"+indiv1['algorithm']+\"\\n\\\nCode:\\n\\\n\"+indiv1['code']+\"\\n\\\nPlease identify the main algorithm parameters and assist me in creating a new algorithm that has a different parameter settings of the score function provided. \\n\"\\\n\"First, describe your new algorithm and main steps in one sentence. \\\nThe description must be inside a brace. Next, implement it in Python as a function named \\\n\"+self.prompt_func_name +\". This function should accept \"+str(len(self.prompt_func_inputs))+\" input(s): \"\\\n+self.joined_inputs+\". The function should return \"+str(len(self.prompt_func_outputs))+\" output(s): \"\\\n+self.joined_outputs+\". \"+self.prompt_inout_inf+\" \"\\\n+self.prompt_other_inf+\"\\n\"+\"Do not give additional explanations.\"\n return prompt_content\n\n\n def _get_alg(self,prompt_content):\n\n response = self.interface_llm.get_response(prompt_content)\n\n algorithm = re.findall(r\"\\{(.*)\\}\", response, re.DOTALL)\n if len(algorithm) == 0:\n if 'python' in response:\n algorithm = re.findall(r'^.*?(?=python)', response,re.DOTALL)\n elif 'import' in response:\n algorithm = re.findall(r'^.*?(?=import)', response,re.DOTALL)\n else:\n algorithm = re.findall(r'^.*?(?=def)', response,re.DOTALL)\n\n code = re.findall(r\"import.*return\", response, re.DOTALL)\n if len(code) == 0:\n code = re.findall(r\"def.*return\", response, re.DOTALL)\n\n n_retry = 1\n while (len(algorithm) == 0 or len(code) == 0):\n if self.debug_mode:\n print(\"Error: algorithm or code not identified, wait 1 seconds and retrying ... \")\n\n response = self.interface_llm.get_response(prompt_content)\n\n algorithm = re.findall(r\"\\{(.*)\\}\", response, re.DOTALL)\n if len(algorithm) == 0:\n if 'python' in response:\n algorithm = re.findall(r'^.*?(?=python)', response,re.DOTALL)\n elif 'import' in response:\n algorithm = re.findall(r'^.*?(?=import)', response,re.DOTALL)\n else:\n algorithm = re.findall(r'^.*?(?=def)', response,re.DOTALL)\n\n code = re.findall(r\"import.*return\", response, re.DOTALL)\n if len(code) == 0:\n code = re.findall(r\"def.*return\", response, re.DOTALL)\n \n if n_retry > 3:\n break\n n_retry +=1\n\n algorithm = algorithm[0]\n code = code[0] \n\n code_all = code+\" \"+\", \".join(s for s in self.prompt_func_outputs) \n\n\n return [code_all, algorithm]\n\n\n def i1(self):\n\n prompt_content = self.get_prompt_i1()\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ i1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def e1(self,parents):\n \n prompt_content = self.get_prompt_e1(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ e1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def e2(self,parents):\n \n prompt_content = self.get_prompt_e2(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ e2 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def m1(self,parents):\n \n prompt_content = self.get_prompt_m1(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ m1 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]\n \n def m2(self,parents):\n \n prompt_content = self.get_prompt_m2(parents)\n\n if self.debug_mode:\n print(\"\\n >>> check prompt for creating algorithm using [ m2 ] : \\n\", prompt_content )\n print(\">>> Press 'Enter' to continue\")\n input()\n \n [code_all, algorithm] = self._get_alg(prompt_content)\n\n if self.debug_mode:\n print(\"\\n >>> check designed algorithm: \\n\", algorithm)\n print(\"\\n >>> check designed code: \\n\", code_all)\n print(\">>> Press 'Enter' to continue\")\n input()\n\n return [code_all, algorithm]" }, { "path": "eoh/src/eoh/methods/localsearch/ls_interface_EC.py", "content": "import numpy as np\nimport time\nfrom .ls_evolution import Evolution\nimport warnings\nfrom joblib import Parallel, delayed\nfrom .evaluator_accelerate import add_numba_decorator\nimport re\n\nclass InterfaceEC():\n def __init__(self, pop_size, m, api_endpoint, api_key, llm_model, debug_mode, interface_prob, select,n_p, **kwargs):\n # -------------------- RZ: use local LLM --------------------\n assert 'use_local_llm' in kwargs\n assert 'url' in kwargs\n # -----------------------------------------------------------\n\n # LLM settings\n self.pop_size = pop_size\n self.interface_eval = interface_prob\n prompts = interface_prob.prompts\n self.evol = Evolution(api_endpoint, api_key, llm_model, debug_mode,prompts, **kwargs)\n self.m = m\n self.debug = debug_mode\n\n if not self.debug:\n warnings.filterwarnings(\"ignore\")\n\n self.select = select\n self.n_p = n_p\n \n def code2file(self,code):\n with open(\"./ael_alg.py\", \"w\") as file:\n # Write the code to the file\n file.write(code)\n return \n \n def add2pop(self,population,offspring):\n for ind in population:\n if ind['objective'] == offspring['objective']:\n if self.debug:\n print(\"duplicated result, retrying ... \")\n return False\n population.append(offspring)\n return True\n \n def check_duplicate(self,population,code):\n for ind in population:\n if code == ind['code']:\n return True\n return False\n\n # def population_management(self,pop):\n # # Delete the worst individual\n # pop_new = heapq.nsmallest(self.pop_size, pop, key=lambda x: x['objective'])\n # return pop_new\n \n # def parent_selection(self,pop,m):\n # ranks = [i for i in range(len(pop))]\n # probs = [1 / (rank + 1 + len(pop)) for rank in ranks]\n # parents = random.choices(pop, weights=probs, k=m)\n # return parents\n\n def population_generation(self):\n \n _,population = self.get_algorithm([],'i1')\n \n while population[0]['objective'] == None:\n _,population = self.get_algorithm([],'i1')\n \n return population\n \n def population_generation_seed(self,seeds,n_p):\n\n population = []\n\n fitness = Parallel(n_jobs=n_p)(delayed(self.interface_eval.evaluate)(seed['code']) for seed in seeds)\n\n for i in range(len(seeds)):\n try:\n seed_alg = {\n 'algorithm': seeds[i]['algorithm'],\n 'code': seeds[i]['code'],\n 'objective': None,\n 'other_inf': None\n }\n\n obj = np.array(fitness[i])\n seed_alg['objective'] = np.round(obj, 5)\n population.append(seed_alg)\n\n except Exception as e:\n print(\"Error in seed algorithm\")\n exit()\n\n print(\"Initiliazation finished! Get \"+str(len(seeds))+\" seed algorithms\")\n\n return population\n \n\n def _get_alg(self,pop,operator):\n offspring = {\n 'algorithm': None,\n 'code': None,\n 'objective': None,\n 'other_inf': None\n }\n if operator == \"i1\":\n parents = None\n [offspring['code'],offspring['algorithm']] = self.evol.i1() \n elif operator == \"m1\":\n parents = self.select.parent_selection(pop,1)\n [offspring['code'],offspring['algorithm']] = self.evol.m1(parents[0]) \n else:\n print(f\"Evolution operator [{operator}] has not been implemented ! \\n\") \n\n return parents, offspring\n\n def get_offspring(self, pop, operator):\n\n try:\n p, offspring = self._get_alg(pop, operator)\n \n # Regular expression pattern to match function definitions\n pattern = r\"def\\s+(\\w+)\\s*\\(.*\\):\"\n\n # Search for function definitions in the code\n match = re.search(pattern, offspring['code'])\n\n function_name = match.group(1)\n\n code = add_numba_decorator(program=offspring['code'], function_name=function_name)\n\n n_retry= 1\n while self.check_duplicate(pop, code):\n if self.debug:\n print(\"duplicated code, wait 1 second and retrying ... \")\n p, offspring = self._get_alg(pop, operator)\n\n # Regular expression pattern to match function definitions\n pattern = r\"def\\s+(\\w+)\\s*\\(.*\\):\"\n\n # Search for function definitions in the code\n match = re.search(pattern, offspring['code'])\n\n function_name = match.group(1)\n\n code = add_numba_decorator(program=offspring['code'], function_name=function_name)\n \n if n_retry > 3:\n break\n \n n_retry += 1\n #self.code2file(offspring['code'])\n \n fitness = self.interface_eval.evaluate(code)\n offspring['objective'] = np.round(fitness, 5)\n\n except Exception as e:\n #print(e)\n \n offspring = {\n 'algorithm': None,\n 'code': None,\n 'objective': None,\n 'other_inf': None\n }\n p = None\n\n # Round the objective values\n return p, offspring\n\n def get_algorithm(self, pop, operator):\n \n\n from multiprocessing import TimeoutError\n import concurrent.futures\n from joblib.externals.loky.process_executor import TerminatedWorkerError\n \n\n results = []\n try:\n results = Parallel(n_jobs=self.n_p, timeout=20)(delayed(self.get_offspring)(pop, operator) for _ in range(self.pop_size))\n # for result in results:\n # if isinstance(result, (TimeoutError, concurrent.futures.TimeoutError)):\n # print(\"Timeout occurred for a job.\")\n # else:\n # results_collected.append(result)\n except (TimeoutError, concurrent.futures.TimeoutError, TerminatedWorkerError):\n print(\"Overall Timeout or terminate error occurred\")\n \n time.sleep(2)\n\n out_p = []\n out_off = []\n\n for p, off in results:\n out_p.append(p)\n out_off.append(off)\n return out_p, out_off\n # def get_algorithm(self,pop,operator, pop_size, n_p):\n \n # # perform it pop_size times with n_p processes in parallel\n # p,offspring = self._get_alg(pop,operator)\n # while self.check_duplicate(pop,offspring['code']):\n # if self.debug:\n # print(\"duplicated code, wait 1 second and retrying ... \")\n # time.sleep(1)\n # p,offspring = self._get_alg(pop,operator)\n # self.code2file(offspring['code'])\n # try:\n # fitness= self.interface_eval.evaluate()\n # except:\n # fitness = None\n # offspring['objective'] = fitness\n # #offspring['other_inf'] = first_gap\n # while (fitness == None):\n # if self.debug:\n # print(\"warning! error code, retrying ... \")\n # p,offspring = self._get_alg(pop,operator)\n # while self.check_duplicate(pop,offspring['code']):\n # if self.debug:\n # print(\"duplicated code, wait 1 second and retrying ... \")\n # time.sleep(1)\n # p,offspring = self._get_alg(pop,operator)\n # self.code2file(offspring['code'])\n # try:\n # fitness= self.interface_eval.evaluate()\n # except:\n # fitness = None\n # offspring['objective'] = fitness\n # #offspring['other_inf'] = first_gap\n # offspring['objective'] = np.round(offspring['objective'],5) \n # #offspring['other_inf'] = np.round(offspring['other_inf'],3)\n # return p,offspring\n" }, { "path": "eoh/src/eoh/methods/management/__init__.py", "content": "" }, { "path": "eoh/src/eoh/methods/management/ls_greedy.py", "content": "\n\ndef population_management(population, new, temperature):\n \n if (new['objective'] != None) and (len(population) == 0 or new['objective'] < population[0]['objective']):\n population[0] = new\n return" }, { "path": "eoh/src/eoh/methods/management/ls_sa.py", "content": "import math\nimport random\n\ndef acceptance_probability(old_cost, new_cost, temperature):\n if new_cost < old_cost:\n return 1.0\n return math.exp(((old_cost - new_cost)/old_cost) / temperature)\n\ndef population_management(population, new, temperature):\n current_best = population[0]\n \n if (new['objective'] != None) and (len(population) == 0 or acceptance_probability(current_best['objective'], new['objective'], temperature) > random.random()):\n population[0] = new\n \n return" }, { "path": "eoh/src/eoh/methods/management/pop_greedy.py", "content": "import heapq\n\ndef population_management(pop,size):\n pop = [individual for individual in pop if individual['objective'] is not None]\n if size > len(pop):\n size = len(pop)\n unique_pop = [] \n unique_objectives = []\n for individual in pop:\n if individual['objective'] not in unique_objectives:\n unique_pop.append(individual)\n unique_objectives.append(individual['objective'])\n # Delete the worst individual\n #pop_new = heapq.nsmallest(size, pop, key=lambda x: x['objective'])\n pop_new = heapq.nsmallest(size, unique_pop, key=lambda x: x['objective'])\n return pop_new" }, { "path": "eoh/src/eoh/methods/methods.py", "content": "\nfrom .selection import prob_rank,equal,roulette_wheel,tournament\nfrom .management import pop_greedy,ls_greedy,ls_sa\n\nclass Methods():\n def __init__(self,paras,problem) -> None:\n self.paras = paras \n self.problem = problem\n if paras.selection == \"prob_rank\":\n self.select = prob_rank\n elif paras.selection == \"equal\":\n self.select = equal\n elif paras.selection == 'roulette_wheel':\n self.select = roulette_wheel\n elif paras.selection == 'tournament':\n self.select = tournament\n else:\n print(\"selection method \"+paras.selection+\" has not been implemented !\")\n exit()\n\n if paras.management == \"pop_greedy\":\n self.manage = pop_greedy\n elif paras.management == 'ls_greedy':\n self.manage = ls_greedy\n elif paras.management == 'ls_sa':\n self.manage = ls_sa\n else:\n print(\"management method \"+paras.management+\" has not been implemented !\")\n exit()\n\n \n def get_method(self):\n\n if self.paras.method == \"ael\":\n from .ael.ael import AEL\n return AEL(self.paras,self.problem,self.select,self.manage)\n elif self.paras.method == \"eoh\": \n from .eoh.eoh import EOH\n return EOH(self.paras,self.problem,self.select,self.manage)\n elif self.paras.method in ['ls','sa']: \n from .localsearch.ls import LS\n return LS(self.paras,self.problem,self.select,self.manage)\n elif self.paras.method == \"funsearch\": \n from .funsearch.funsearch import FunSearch\n return FunSearch(self.paras,self.problem,self.select,self.manage)\n elif self.paras.method == \"reevo\":\n from .reevo.reevo import ReEVO\n return ReEVO(self.paras,self.problem,self.select,self.manage)\n else:\n print(\"method \"+self.method+\" has not been implemented!\")\n exit()" }, { "path": "eoh/src/eoh/methods/selection/__init__.py", "content": "" }, { "path": "eoh/src/eoh/methods/selection/equal.py", "content": "import random\ndef parent_selection(population, m):\n parents = random.choices(population, k=m)\n return parents" }, { "path": "eoh/src/eoh/methods/selection/prob_rank.py", "content": "import random\ndef parent_selection(pop,m):\n ranks = [i for i in range(len(pop))]\n probs = [1 / (rank + 1 + len(pop)) for rank in ranks]\n parents = random.choices(pop, weights=probs, k=m)\n return parents" }, { "path": "eoh/src/eoh/methods/selection/roulette_wheel.py", "content": "import random\ndef parent_selection(population, m):\n fitness_values = [1 / (fit['objective'] + 1e-6) for fit in population]\n fitness_sum = sum(fitness_values)\n probs = [fit / fitness_sum for fit in fitness_values]\n parents = random.choices(population, weights=probs, k=m)\n return parents" }, { "path": "eoh/src/eoh/methods/selection/tournament.py", "content": "\nimport random\n\ndef parent_selection(population, m):\n tournament_size = 2\n parents = []\n while len(parents) < m:\n tournament = random.sample(population, tournament_size)\n tournament_fitness = [fit['objective'] for fit in tournament]\n winner = tournament[tournament_fitness.index(min(tournament_fitness))]\n parents.append(winner)\n return parents" }, { "path": "eoh/src/eoh/problems/__init__.py", "content": "" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/README.MD", "content": "# This is the implementation for L-AutoDA\n\n## Required Package\nBefore running the code, please install the following packages:\n```\npip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118\npip install timm\npip install foolbox\n```\n`foolbox`is used for adversarial attack.\n\n`timm` is used for loading pretrained models for later test.\n\n`torch` is used for running neural networks." }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/ael_evaluation.py", "content": "import importlib\nimport time\nimport torch\nimport foolbox as fb\nfrom utils.get_data import get_data_by_id\nfrom utils.get_model import get_model\nimport os\nimport sys\nABS_PATH = os.path.dirname(os.path.abspath(__file__))\nsys.path.append(ABS_PATH) # This is for finding all the modules\n\nfrom attacks.evo_for_ael_no_mem import EvoAttack\n\n# File Location to Store the datasets\nDATASET = \"cifar10\" # Dataset name, if use imagenet, must download in advance\nDATASET_PATH = os.path.join(ABS_PATH, \"datasets\", DATASET) # store the datasets under the directory of current file\nTEST_IMAGES = 8\nMODEL_PATH = os.path.join(ABS_PATH, \"models\") # store the models under the directory of current file\n\n\n\nclass Evaluation():\n def __init__(self, dataset_path=DATASET_PATH, dataset_name=DATASET, num_test_images=TEST_IMAGES, model_path=MODEL_PATH, **kwargs) -> None:\n self.test_set = get_data_by_id(dataset_name, use_train_data=False, data_path=dataset_path)\n self.test_loader = torch.utils.data.DataLoader(\n self.test_set, batch_size=num_test_images, shuffle=False, pin_memory=True\n )\n self.model = get_model(model_path=model_path)\n self.steps = 2000\n self.running_time = 10\n\n # @func_set_timeout(5)\n def greedy(self, eva):\n if torch.cuda.is_available():\n self.model.cuda()\n\n fmodel = fb.PyTorchModel(self.model, bounds=(0, 1))\n attack_use = EvoAttack(eva, steps=8000)\n for i, (x, y) in enumerate(self.test_loader):\n if torch.cuda.is_available():\n x = x.cuda()\n y = y.cuda()\n img_adv = attack_use.run(fmodel, x, y)\n # y_pred = self.model(x)\n # y_pred_adv = self.model(img_adv)\n distance = torch.linalg.norm((x - img_adv).flatten(start_dim=1), axis=1)\n distance = distance.mean()\n distance = float(distance.cpu().numpy())\n print(\"average dis: \",distance)\n return distance\n\n def evaluate(self):\n time.sleep(1)\n try:\n heuristic_module = importlib.import_module(\"ael_alg\")\n eva = importlib.reload(heuristic_module)\n fitness = self.greedy(eva)\n return fitness\n except Exception as e:\n print(\"Error:\", str(e))\n return None\n \n\n\n" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/ael_prompts.py", "content": "\nclass GetPrompts():\n def __init__(self):\n self.prompt_task = (\n \"Given an image 'org_img', its adversarial image 'best_adv_img', \"\n \"and a random normal noise 'std_normal_noise', \"\n \"you need to design an algorithm to combine them to search for a new adversarial example 'x_new'. \"\n \"'hyperparams' ranges from 0.5 to 1.5. It gets larger when \"\n \"this algorithm outputs more adversarial examples, and vice versa. \"\n \"It can be used to control the step size of the search.\"\n \"Operations you may use include: adding, subtracting, multiplying, dividing, \"\n \"dot product, and l2 norm computation. Design an novel algorithm with various search techniques. Your code \"\n \"should be able to run without further assistance. \"\n )\n self.prompt_func_name = \"draw_proposals\"\n self.prompt_func_inputs = [\"org_img\",\"best_adv_img\",\"std_normal_noise\", \"hyperparams\"]\n self.prompt_func_outputs = [\"x_new\"]\n self.prompt_inout_inf = (\n \"'org_img', 'best_adv_img', 'x_new', and 'std_normal_noise' are shaped as (3, img_height, img_width). \"\n \"The bound of images are [0, 1]. \"\n \"'std_normal_noise' contains random normal noises. \"\n \"'hyperparams' is a numpy array with shape (1,). \"\n )\n self.prompt_other_inf = (\"All inouts are numpy arrays.\")\n\n def get_task(self):\n return self.prompt_task\n \n def get_func_name(self):\n return self.prompt_func_name\n \n def get_func_inputs(self):\n return self.prompt_func_inputs\n \n def get_func_outputs(self):\n return self.prompt_func_outputs\n \n def get_inout_inf(self):\n return self.prompt_inout_inf\n\n def get_other_inf(self):\n return self.prompt_other_inf\n \n# def get_task():\n# task = \"Task: Given a set of nodes with their coordinates, \\\n# you need to find the shortest route that visits each node once and returns to the starting node. \\\n# The task can be solved step-by-step by starting from the current node and iteratively choosing the next node. \\\n# You should create a totally new strategy for me (different from the heuristics in the literature) \\\n# to select the next node in each step, using information including the current node, destination node, unvisited nodes, and distances between them. \\\n# Provide a description of the new algorithm in no more than two sentences. The description must be inside a brace. \\\n# Provide the Python code for the new algorithm. The code is a function called 'select_next_node' that takes inputs 'current_node', 'destination_node', 'unvisited_nodes', and 'distance_matrix', \\\n# and outputs the 'next_node', where 'current_node', 'destination_node', 'next_node', and 'unvisited_nodes' are node id. Be creative and do not give additional explanation.\"\n# return prompt_content\n \n\n# def get_crossover(indiv1,indiv2):\n# prompt_content = \"Task: Given a set of nodes with their coordinates, \\\n# you need to find the shortest route that visits each node once and returns to the starting node. \\\n# The task can be solved step-by-step by starting from the current node and iteratively choosing the next node. \\\n# I have two algorithms with their codes to select the next node in each step. \\\n# The first algorithm and the corresponding code are: \\n\\\n# Algorithm description: \"+indiv1['algorithm']+\"\\n\\\n# Code:\\n\\\n# \"+indiv1['code']+\"\\n\\\n# The second algorithm and the corresponding code are: \\n\\\n# Algorithm description: \"+indiv2['algorithm']+\"\\n\\\n# Code:\\n\\\n# \"+indiv2['code']+\"\\n\\\n# Please help me create a new algorithm that motivated by the given algorithms. \\\n# Provide a description of the new algorithm in no more than two sentences. The description must be inside a brace. \\\n# Provide the Python code for the new algorithm. The code is a function called 'select_next_node' that takes inputs 'current_node', 'destination_node', 'unvisited_nodes', and 'distance_matrix', \\\n# and outputs the 'next_node', where 'current_node', 'destination_node', 'next_node', and 'unvisited_nodes' are node id. Be creative and do not give additional explanation.\"\n# return prompt_content\n \n# def get_mutation(indiv1):\n# prompt_content = \"Task: Given a set of nodes with their coordinates, \\\n# you need to find the shortest route that visits each node once and returns to the starting node. \\\n# The task can be solved step-by-step by starting from the current node and iteratively choosing the next node. \\\n# I have an algorithm with its code to select the next node in each step as follows. \\\n# Algorithm description: \"+indiv1['algorithm']+\"\\n\\\n# Code:\\n\\\n# \"+indiv1['code']+\"\\n\\\n# Please assist me in creating a modified version of the algorithm provided. \\\n# Provide a description of the new algorithm in no more than two sentences. The description must be inside a brace. \\\n# Provide the Python code for the new algorithm. The code is a function called 'select_next_node' that takes inputs 'current_node', 'destination_node', 'unvisited_nodes', and 'distance_matrix', \\\n# and outputs the 'next_node', where 'current_node', 'destination_node', 'next_node', and 'unvisited_nodes' are node id. Be creative and do not give additional explanation.\"\n# return prompt_content\nif __name__ == \"__main__\":\n getprompts = GetPrompts()\n print(getprompts.get_task())\n import numpy as np\n def select_next_node(current_node, destination_node, unvisited_nodes, distance_matrix):\n potentials = []\n for node in unvisited_nodes:\n distance_to_current = distance_matrix[current_node, node]\n distance_to_destination = distance_matrix[node, destination_node]\n potential = distance_to_destination / (distance_to_current + distance_to_destination)\n potentials.append(potential)\n next_node = unvisited_nodes[np.argmax(potentials)]\n return next_node" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/attacks/__init__.py", "content": "" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/attacks/evo_for_ael_no_mem.py", "content": "from typing import Union, Tuple, Optional, Any\nfrom typing_extensions import Literal\nimport numpy as np\nimport eagerpy as ep\nimport logging\nimport torch\nimport time\nimport math\n\nfrom foolbox.devutils import flatten\nfrom foolbox.devutils import atleast_kd\n\nfrom foolbox.types import Bounds\n\nfrom foolbox.models import Model\n\nfrom foolbox.criteria import Criterion\n\nfrom foolbox.distances import l2\n\nfrom foolbox.tensorboard import TensorBoard\n\nfrom foolbox.attacks.blended_noise import LinearSearchBlendedUniformNoiseAttack\n\nfrom foolbox.attacks.base import MinimizationAttack\nfrom foolbox.attacks.base import T\nfrom foolbox.attacks.base import get_criterion\nfrom foolbox.attacks.base import get_is_adversarial\nfrom foolbox.attacks.base import raise_if_kwargs\nfrom foolbox.attacks.base import verify_input_bounds\n\n\n\nclass EvoAttack(MinimizationAttack):\n distance = l2\n # can only perform l2 attacks\n def __init__(\n self,\n library_use,\n init_attack: Optional[MinimizationAttack] = None,\n steps: int = 25000,\n min_epsilon: float = 0.0,\n ):\n if init_attack is not None and not isinstance(init_attack, MinimizationAttack):\n raise NotImplementedError\n self.init_attack = init_attack\n self.steps = steps\n self.min_epsilon = min_epsilon\n self.library_use = library_use\n\n def run(\n self,\n model: Model,\n inputs: T,\n criterion: Union[Criterion, T],\n *,\n early_stop: Optional[float] = None,\n starting_points: Optional[T] = None,\n **kwargs: Any,\n ) -> T:\n raise_if_kwargs(kwargs)\n originals, restore_type = ep.astensor_(inputs)\n del inputs, kwargs\n\n verify_input_bounds(originals, model)\n\n criterion = get_criterion(criterion)\n is_adversarial = get_is_adversarial(criterion, model)\n\n if starting_points is None:\n init_attack: MinimizationAttack\n if self.init_attack is None:\n init_attack = LinearSearchBlendedUniformNoiseAttack(steps=50)\n logging.info(\n f\"Neither starting_points nor init_attack given. Falling\"\n f\" back to {init_attack!r} for initialization.\"\n )\n else:\n init_attack = self.init_attack\n best_advs = init_attack.run(\n model, originals, criterion, early_stop=early_stop\n )\n else:\n best_advs = ep.astensor(starting_points)\n\n is_adv = is_adversarial(best_advs)\n if not is_adv.all():\n failed = is_adv.logical_not().float32().sum()\n if starting_points is None:\n raise ValueError(\n f\"init_attack failed for {failed} of {len(is_adv)} inputs\"\n )\n else:\n raise ValueError(\n f\"{failed} of {len(is_adv)} starting_points are not adversarial\"\n )\n del starting_points\n\n N = len(originals)\n ndim = originals.ndim\n min_, max_ = model.bounds\n np_bounds = np.array([min_, max_])\n\n # converting back to torch\n # candidate_history = np.zeros((100, *originals.shape))\n # adv_history = np.zeros((100, originals.shape[0]))\n # history_idx = 0\n t1 = time.time()\n\n self.hyperparams = 0.001 * np.ones(originals.shape[0])\n alpha_p = 0.95\n p = np.zeros(originals.shape[0])\n for step in range(1, self.steps + 1):\n originals = originals.raw\n best_advs = best_advs.raw\n\n orginals_np = originals.cpu().numpy()\n best_advs_np = best_advs.cpu().numpy()\n\n candidates_np = np.zeros(orginals_np.shape)\n standard_noise_np = np.random.normal(size=orginals_np.shape)\n for candidate_i in range(orginals_np.shape[0]):\n candidates_np_i = self.library_use.draw_proposals(\n orginals_np[candidate_i],\n best_advs_np[candidate_i],\n standard_noise_np[candidate_i],\n self.hyperparams[candidate_i:candidate_i + 1],\n )\n candidates_np[candidate_i] = candidates_np_i\n\n candidates_np = np.clip(candidates_np, np_bounds[0], np_bounds[1])\n\n t2 = time.time()\n if t2 - t1 > 120:\n return best_advs\n candidates = torch.from_numpy(candidates_np).float().to(originals.device)\n\n is_adv = is_adversarial(candidates)\n # is_adv_np = is_adv.cpu().numpy()\n # if history_idx == 100:\n # candidate_history = np.concatenate([candidate_history[:-1], candidates_np[None, :]])\n # adv_history = np.concatenate([adv_history[:-1], is_adv_np[None, :]])\n # history_idx = 99\n # else:\n # candidate_history[history_idx] = candidates_np\n # adv_history[history_idx] = is_adv_np\n # history_idx += 1\n originals = ep.astensor(originals)\n candidates = ep.astensor(candidates)\n\n is_adv = ep.astensor(is_adv)\n best_advs = ep.astensor(best_advs)\n\n distances = ep.norms.l2(flatten(originals - candidates), axis=-1)\n source_norms = ep.norms.l2(flatten(originals - best_advs), axis=-1)\n closer = distances < source_norms\n is_best_adv = ep.logical_and(is_adv, closer)\n is_best_adv = atleast_kd(is_best_adv, ndim)\n\n # update params\n is_best_adv_np = is_best_adv.raw.cpu().numpy()\n is_best_adv_np = is_best_adv_np.astype(float).reshape(-1)\n p = alpha_p * p + (1 - alpha_p) * is_best_adv_np\n self.hyperparams *= np.power(self._f_p(p), 1 / 10)\n\n best_advs = ep.where(is_best_adv, candidates, best_advs)\n\n self.current_epsilons = ep.norms.l2(flatten(best_advs - originals), axis=-1)\n if (self.current_epsilons < self.min_epsilon).all():\n return restore_type(best_advs)\n # print(\"Step {}: {:.5f}\".format(step, self.current_epsilons.mean()))\n print(\"Step {}: {:.5f}\".format(self.steps, self.current_epsilons.mean()))\n\n return restore_type(best_advs)\n\n def _f_p(self, p):\n # piecewise linear function\n # f(0)=l, f(1)=h, f(0.25)=1\n l = 0.5\n h = 1.5\n p_threshold = 0.25\n p_less_idx = p < p_threshold\n p_greater_idx = p >= p_threshold\n f_p = np.zeros_like(p)\n f_p[p_less_idx] = l + (1 - l) * p[p_less_idx] / p_threshold\n f_p[p_greater_idx] = 1 + (h - 1) * (p[p_greater_idx] - p_threshold) / (\n 1 - p_threshold\n )\n return f_p\n" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/runAEL.py", "content": "test = True\nif test:\n import sys\n import os\n ABS_PATH = os.path.dirname(os.path.abspath(__file__))\n ROOT_PATH = os.path.join(ABS_PATH, \"..\", \"..\")\n sys.path.append(ROOT_PATH) # This is for finding all the modules\n from aell.src.ael import ael\n from aell.src.ael.utils import createFolders\nelse:\n from aell import ael\n from aell.utils import createFolders\n\n\n\n### LLM settings ###\napi_endpoint = \"oa.api2d.site\"\napi_key = \"your key\"\nllm_model = \"gpt-3.5-turbo-1106\" \n\n### output path ###\noutput_path = \"./\" # default folder for ael outputs\ncreateFolders.create_folders(output_path)\n\n\nload_data = {\n 'use_seed' : False,\n 'seed_path' : None,\n \"use_pop\": False,\n \"pop_path\": output_path + \"/ael_results/pops/population_generation_0.json\",\n \"n_pop_initial\": 0\n}\n\n### Experimental settings ###\npop_size = 10 # number of algorithms in each population, default = 10\nn_pop = 20 # number of populations, default = 10\np1 = 1.0 # probability of crossover, default = 1.0\np2 = 0.5 # probability of mutation, default = 0.5\noperators = ['e1','e2','m1','m2'] # evolution operators: ['e1','e2','m1','m2'], default = ['e1','m1']\nm = 2 # number of parents for 'e1' and 'e2' operators, default = 2\noperator_weights = [1,1,1,1] # weights for operators, i.e., the probability of use the operator in each iteration , default = [1,1,1,1]\n\n### Debug model ###\ndebug_mode = False # if debug\n\n\n\n# AEL\nprint(\">>> Start AEL \")\n\nalgorithmEvolution = ael.AEL(\n api_endpoint,api_key,llm_model,pop_size,n_pop,operators,m,operator_weights,load_data,output_path,debug_mode\n)\n\n# run AEL\nalgorithmEvolution.run()\n\nprint(\"AEL successfully finished !\")\n" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/utils/__init__.py", "content": "" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/utils/get_data.py", "content": "import torch\nimport random\nimport numpy as np\n\nfrom torchvision import datasets, transforms\n\n\ndef setup_seed(seed):\n torch.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n np.random.seed(seed)\n random.seed(seed)\n torch.backends.cudnn.deterministic = True\n\n\ndef get_data_by_id(dataset_name, use_train_data=False, data_path=None):\n assert dataset_name in ['cifar10', 'imagenet', 'mnist']\n assert data_path is not None\n if dataset_name == 'cifar10':\n transform = transforms.Compose([transforms.ToTensor()])\n # transform = None\n test_set = datasets.CIFAR10(\n root=data_path,\n train=use_train_data, download=True, transform=transform)\n elif dataset_name == 'imagenet':\n transform = transforms.Compose([transforms.Resize(232),\n transforms.CenterCrop(224),\n transforms.ToTensor()])\n test_set = datasets.ImageNet(\n root=data_path,\n split='val' if not use_train_data else 'train', transform=transform)\n elif dataset_name == 'mnist':\n # transform = transforms.Compose([transforms.ToTensor()])\n transform = None\n test_set = datasets.MNIST(\n root=data_path, train=use_train_data, download=True,\n transform=transform)\n else:\n raise NotImplementedError(\"Dataset not supported\")\n\n return test_set\n\n\n# The code for creating a subset of the dataset (1000 images)\ndef create_idx_by_id(dataset_name, data_set, save_path=None):\n if dataset_name == 'cifar10':\n unique_label_list = [i for i in range(10)]\n label_idx_list = []\n for each_unique_label in unique_label_list:\n idx = np.where(np.array(data_set.targets) == each_unique_label)[0]\n rand_perm = np.random.permutation(idx.shape[0])[0:100]\n idx = idx[rand_perm]\n label_idx_list.append(idx)\n subset_idx = np.stack(label_idx_list)\n subset_idx = subset_idx.reshape(-1)\n subset_idx = subset_idx.astype(int)\n np.savetxt(save_path, subset_idx, fmt='%i')\n elif dataset_name == 'imagenet':\n subset_idx = np.random.permutation(len(data_set))[0:1000]\n np.savetxt(save_path, subset_idx, fmt='%i')\n" }, { "path": "eoh/src/eoh/problems/machinelearning/L_AutoDA/utils/get_model.py", "content": "import torchvision\nimport timm\nimport torch\nimport torch.nn as nn\nimport os\nimport sys\n\n# sys.path.append(os.path.join(os.path.dirname(__file__), '..'))\nABS_PATH = os.path.dirname(os.path.abspath(__file__))\n# MODEL_PATH = \"{}/../models\".format(ABS_PATH)\n\n\ndef get_model(model_name=\"cifar10\", model_path=None):\n assert model_name in [\"cifar10\", \"imagenet\"]\n assert model_path is not None\n return {\n \"cifar10\": get_cifar10_model,\n \"imagenet\": get_imagenet_model\n }[model_name](model_path=model_path)\n\n\ndef get_cifar10_model(model_path=None):\n preprocessor = torchvision.transforms.Normalize(\n mean=[0.4914, 0.4822, 0.4465],\n std=[0.2023, 0.1994, 0.201]\n )\n\n net = timm.create_model(\"resnet18\", pretrained=False)\n # override model\n net.conv1 = nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n net.maxpool = nn.Identity() # type: ignore\n net.fc = nn.Linear(512, 10)\n\n net.load_state_dict(\n torch.hub.load_state_dict_from_url(\n \"https://huggingface.co/edadaltocg/resnet18_cifar10/resolve/main/pytorch_model.bin\",\n model_dir=model_path,\n map_location=\"cpu\",\n file_name=\"resnet18_cifar10.pth\",\n )\n )\n model = nn.Sequential(\n preprocessor,\n net\n )\n model.eval()\n return model\n\n\ndef get_imagenet_model(model_path=None):\n preprocessor = torchvision.transforms.Normalize(\n mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225]\n )\n net = torchvision.models.resnet50(\n weights=torchvision.models.ResNet50_Weights.IMAGENET1K_V1\n )\n model = nn.Sequential(\n preprocessor,\n net\n )\n model.eval()\n return model\n" }, { "path": "eoh/src/eoh/problems/optimization/__init__.py", "content": "" }, { "path": "eoh/src/eoh/problems/optimization/bp_online/__init__.py", "content": "" }, { "path": "eoh/src/eoh/problems/optimization/bp_online/get_instance.py", "content": "import numpy as np\nimport pickle\nclass GetData():\n def __init__(self) -> None:\n self.datasets = {}\n # Data from the Weibull 5k test dataset, containing 5 bin packing instances\n # each with 5,000 items.\n self.datasets['Weibull 5k'] = {'test_0': {'capacity': 100, 'num_items': 5000, 'items': [48, 66, 48, 32, 72, 37, 41, 21, 58, 35, 18, 53, 52, 42, 51, 30, 42, 44, 58, 62, 28, 20, 27, 53, 59, 56, 46, 60, 21, 49, 29, 58, 31, 47, 34, 41, 28, 49, 22, 37, 31, 27, 50, 46, 39, 52, 40, 41, 31, 57, 53, 57, 35, 39, 38, 40, 34, 22, 30, 48, 34, 34, 48, 53, 23, 57, 50, 67, 18, 40, 38, 38, 42, 53, 38, 37, 53, 62, 22, 51, 34, 51, 24, 92, 60, 29, 39, 49, 24, 33, 67, 65, 62, 57, 60, 29, 53, 29, 54, 52, 37, 59, 55, 69, 20, 41, 47, 44, 36, 48, 61, 33, 53, 36, 47, 38, 39, 35, 41, 31, 42, 41, 45, 49, 25, 20, 71, 61, 35, 33, 42, 11, 39, 68, 43, 30, 51, 31, 68, 29, 40, 45, 41, 23, 46, 65, 37, 60, 45, 38, 28, 45, 42, 30, 39, 59, 36, 60, 58, 32, 49, 19, 55, 46, 55, 53, 46, 32, 56, 29, 23, 22, 26, 19, 37, 24, 50, 44, 33, 27, 26, 34, 38, 21, 58, 48, 66, 37, 40, 10, 37, 27, 56, 30, 49, 19, 52, 17, 41, 29, 38, 53, 21, 36, 37, 23, 35, 26, 25, 33, 11, 34, 18, 69, 36, 50, 40, 19, 65, 51, 53, 35, 35, 45, 21, 27, 60, 35, 56, 14, 65, 40, 24, 39, 49, 85, 54, 32, 28, 27, 9, 28, 44, 47, 65, 59, 23, 46, 36, 46, 18, 20, 20, 36, 50, 71, 57, 63, 31, 35, 47, 35, 35, 41, 48, 19, 53, 69, 26, 43, 45, 27, 52, 19, 49, 45, 29, 32, 29, 22, 52, 15, 47, 39, 26, 41, 27, 31, 63, 50, 21, 30, 21, 42, 43, 21, 71, 21, 34, 29, 80, 41, 37, 51, 35, 33, 45, 26, 44, 30, 41, 22, 55, 26, 43, 35, 15, 31, 32, 53, 36, 33, 25, 19, 29, 64, 56, 17, 30, 13, 66, 19, 39, 51, 38, 39, 54, 37, 37, 17, 8, 45, 58, 19, 48, 51, 41, 53, 69, 33, 37, 29, 25, 41, 54, 51, 26, 29, 66, 60, 36, 33, 17, 31, 48, 73, 16, 26, 46, 25, 25, 33, 57, 49, 28, 62, 44, 22, 19, 65, 25, 60, 39, 39, 36, 45, 40, 45, 43, 28, 45, 28, 54, 44, 54, 32, 62, 67, 34, 31, 29, 47, 38, 35, 69, 57, 40, 20, 37, 27, 56, 25, 57, 54, 36, 45, 56, 49, 35, 77, 71, 53, 46, 41, 25, 50, 50, 44, 79, 52, 19, 44, 43, 36, 40, 36, 36, 35, 51, 35, 41, 67, 47, 46, 13, 53, 56, 37, 41, 46, 36, 70, 29, 18, 35, 59, 7, 51, 36, 52, 24, 40, 21, 74, 21, 23, 28, 47, 43, 40, 50, 61, 65, 17, 59, 60, 52, 53, 19, 51, 63, 59, 25, 42, 50, 50, 60, 61, 27, 37, 25, 55, 69, 45, 51, 36, 47, 20, 56, 39, 20, 43, 50, 34, 42, 37, 60, 48, 18, 41, 42, 35, 34, 46, 20, 61, 57, 25, 42, 72, 16, 39, 29, 64, 37, 44, 39, 32, 47, 61, 23, 41, 21, 38, 33, 67, 60, 54, 66, 51, 70, 39, 34, 47, 16, 38, 48, 54, 15, 34, 34, 14, 22, 25, 32, 11, 19, 44, 32, 36, 43, 20, 55, 46, 38, 62, 43, 35, 19, 47, 31, 17, 42, 31, 39, 49, 37, 53, 36, 64, 29, 19, 42, 47, 45, 9, 45, 52, 59, 35, 67, 25, 27, 55, 44, 47, 38, 17, 24, 61, 68, 35, 36, 18, 23, 50, 20, 36, 35, 48, 32, 29, 62, 23, 32, 36, 25, 15, 57, 50, 43, 43, 30, 24, 56, 52, 65, 17, 48, 29, 64, 52, 20, 45, 60, 54, 38, 57, 27, 32, 20, 44, 18, 18, 32, 38, 36, 39, 17, 41, 42, 67, 39, 21, 30, 61, 40, 43, 31, 16, 40, 41, 38, 38, 11, 43, 40, 17, 41, 65, 48, 42, 47, 24, 86, 26, 29, 48, 34, 19, 55, 65, 53, 68, 43, 41, 28, 50, 49, 15, 42, 26, 14, 45, 26, 61, 54, 25, 44, 28, 43, 43, 18, 44, 21, 52, 47, 38, 32, 55, 54, 24, 75, 38, 53, 24, 24, 39, 63, 32, 47, 32, 67, 32, 43, 25, 52, 47, 48, 50, 56, 18, 48, 64, 66, 37, 36, 42, 30, 37, 53, 32, 73, 40, 55, 30, 38, 34, 60, 39, 22, 43, 32, 13, 44, 41, 23, 48, 28, 42, 22, 34, 49, 55, 27, 34, 38, 43, 35, 71, 61, 44, 32, 22, 27, 82, 38, 50, 30, 54, 29, 48, 45, 45, 42, 64, 36, 44, 26, 52, 12, 32, 46, 50, 23, 56, 54, 23, 47, 46, 38, 60, 45, 38, 58, 48, 53, 37, 34, 45, 25, 38, 32, 11, 46, 38, 32, 42, 58, 59, 12, 50, 49, 44, 46, 37, 53, 58, 47, 34, 45, 39, 58, 31, 29, 36, 38, 36, 49, 56, 45, 34, 28, 7, 31, 42, 15, 49, 51, 47, 26, 20, 52, 26, 50, 32, 34, 33, 51, 73, 17, 45, 40, 35, 24, 30, 46, 42, 21, 11, 49, 32, 67, 50, 47, 54, 44, 57, 55, 36, 51, 37, 26, 35, 20, 42, 32, 46, 30, 33, 44, 67, 23, 47, 45, 39, 14, 37, 41, 29, 59, 53, 21, 15, 49, 37, 56, 19, 28, 48, 41, 30, 27, 32, 10, 83, 58, 22, 40, 46, 52, 34, 34, 43, 22, 17, 28, 67, 58, 35, 33, 18, 11, 44, 35, 20, 60, 50, 44, 23, 49, 29, 44, 66, 37, 44, 15, 62, 27, 41, 52, 32, 44, 28, 11, 32, 28, 72, 35, 21, 54, 42, 57, 37, 26, 37, 43, 49, 24, 57, 37, 37, 41, 19, 27, 40, 49, 50, 14, 59, 61, 34, 35, 53, 33, 36, 31, 42, 32, 60, 20, 46, 41, 31, 12, 59, 22, 60, 53, 22, 58, 19, 27, 23, 37, 32, 42, 58, 24, 38, 29, 26, 57, 17, 34, 34, 17, 35, 61, 48, 45, 31, 38, 22, 47, 38, 25, 47, 47, 43, 38, 46, 52, 45, 39, 64, 21, 35, 31, 32, 44, 46, 31, 75, 48, 23, 47, 31, 34, 22, 24, 50, 28, 32, 23, 49, 53, 51, 30, 70, 36, 28, 54, 14, 61, 61, 37, 24, 38, 34, 43, 26, 38, 44, 55, 42, 33, 35, 29, 28, 18, 19, 51, 39, 28, 54, 43, 43, 41, 27, 29, 17, 14, 44, 46, 77, 55, 34, 61, 45, 29, 24, 32, 38, 15, 72, 9, 19, 25, 59, 21, 53, 13, 42, 38, 29, 30, 39, 59, 41, 13, 38, 46, 21, 49, 41, 28, 19, 61, 24, 15, 52, 34, 23, 55, 31, 36, 54, 45, 66, 69, 37, 54, 69, 50, 62, 15, 49, 29, 56, 25, 64, 30, 34, 25, 23, 46, 52, 59, 40, 58, 59, 58, 57, 21, 25, 44, 28, 41, 44, 13, 17, 81, 29, 68, 61, 42, 38, 66, 10, 57, 49, 63, 31, 67, 63, 20, 65, 35, 14, 73, 55, 37, 69, 46, 48, 24, 39, 42, 45, 27, 48, 43, 24, 30, 41, 24, 43, 49, 45, 61, 56, 43, 39, 59, 61, 36, 22, 54, 38, 73, 44, 26, 49, 50, 44, 44, 30, 26, 16, 46, 29, 25, 54, 26, 52, 63, 61, 23, 23, 44, 31, 48, 27, 32, 28, 33, 46, 41, 35, 29, 56, 62, 81, 58, 67, 7, 46, 79, 36, 18, 37, 48, 34, 48, 56, 38, 18, 27, 33, 53, 21, 37, 43, 31, 50, 27, 39, 25, 41, 58, 24, 46, 43, 62, 28, 51, 20, 65, 57, 70, 15, 31, 73, 13, 32, 64, 32, 17, 60, 37, 35, 27, 49, 38, 42, 37, 49, 26, 51, 66, 19, 20, 63, 44, 21, 40, 44, 65, 44, 50, 51, 26, 45, 53, 46, 35, 65, 26, 62, 37, 24, 64, 13, 60, 54, 46, 37, 31, 48, 29, 18, 31, 12, 45, 31, 29, 31, 32, 35, 40, 40, 26, 41, 55, 21, 14, 47, 54, 41, 64, 13, 17, 68, 28, 11, 47, 65, 35, 25, 56, 68, 48, 25, 67, 43, 38, 10, 56, 31, 69, 42, 61, 45, 40, 54, 34, 32, 48, 65, 52, 58, 40, 28, 21, 20, 53, 41, 28, 45, 25, 69, 47, 38, 62, 30, 47, 16, 35, 61, 29, 29, 32, 76, 51, 50, 38, 58, 33, 48, 48, 48, 19, 22, 66, 42, 53, 35, 17, 30, 27, 45, 24, 52, 14, 32, 63, 44, 34, 31, 72, 28, 43, 17, 40, 58, 54, 25, 38, 41, 46, 22, 34, 26, 56, 31, 29, 19, 56, 46, 38, 57, 40, 30, 46, 36, 61, 34, 39, 52, 49, 8, 56, 49, 21, 30, 23, 34, 43, 50, 49, 70, 53, 19, 47, 48, 47, 22, 22, 49, 33, 53, 28, 39, 55, 32, 41, 31, 24, 30, 32, 42, 33, 31, 54, 38, 22, 63, 42, 29, 54, 50, 56, 39, 49, 38, 40, 33, 42, 61, 59, 22, 26, 41, 19, 71, 54, 46, 31, 47, 45, 21, 53, 40, 31, 67, 45, 66, 37, 21, 38, 45, 34, 41, 41, 45, 32, 46, 66, 60, 43, 41, 31, 56, 64, 39, 65, 19, 70, 38, 66, 28, 35, 26, 35, 20, 60, 31, 52, 30, 28, 26, 34, 50, 50, 57, 33, 48, 18, 28, 20, 68, 43, 41, 19, 36, 58, 56, 27, 48, 14, 45, 52, 31, 65, 40, 31, 19, 58, 43, 67, 16, 55, 60, 25, 43, 44, 29, 76, 50, 32, 55, 21, 37, 51, 64, 60, 41, 22, 31, 37, 30, 60, 33, 57, 40, 32, 10, 36, 33, 75, 47, 18, 64, 50, 32, 29, 41, 17, 38, 64, 58, 57, 44, 29, 50, 21, 66, 42, 40, 20, 39, 25, 44, 42, 18, 57, 46, 29, 42, 11, 17, 49, 38, 22, 3, 43, 34, 38, 21, 65, 44, 24, 28, 58, 51, 73, 34, 35, 36, 64, 59, 54, 16, 22, 39, 35, 18, 40, 50, 29, 43, 41, 11, 27, 49, 86, 49, 27, 44, 28, 19, 31, 31, 78, 23, 25, 44, 17, 34, 36, 22, 39, 6, 31, 41, 34, 37, 35, 36, 62, 65, 18, 25, 42, 39, 61, 41, 61, 55, 58, 32, 56, 44, 37, 35, 39, 41, 39, 58, 59, 45, 42, 50, 46, 76, 62, 27, 50, 50, 66, 30, 59, 34, 9, 32, 12, 30, 47, 32, 30, 48, 41, 33, 71, 39, 47, 49, 20, 28, 67, 29, 35, 28, 17, 45, 72, 48, 26, 52, 26, 71, 34, 60, 27, 64, 20, 54, 34, 57, 38, 68, 38, 45, 54, 21, 39, 41, 13, 39, 31, 22, 53, 44, 52, 18, 41, 22, 34, 30, 29, 12, 38, 62, 51, 61, 11, 35, 46, 33, 49, 9, 38, 50, 35, 38, 52, 42, 68, 48, 69, 50, 56, 40, 55, 34, 66, 25, 34, 25, 28, 53, 51, 40, 51, 77, 26, 29, 42, 36, 44, 43, 39, 62, 54, 42, 34, 7, 59, 65, 21, 39, 51, 57, 25, 28, 47, 37, 33, 66, 47, 31, 52, 46, 25, 51, 41, 41, 24, 47, 41, 47, 42, 65, 56, 40, 39, 68, 9, 50, 53, 27, 59, 49, 38, 38, 52, 29, 15, 46, 40, 47, 40, 45, 21, 36, 31, 27, 35, 48, 50, 54, 21, 32, 47, 29, 24, 35, 37, 38, 40, 51, 52, 56, 29, 17, 40, 51, 41, 28, 16, 55, 38, 25, 43, 43, 58, 55, 63, 46, 24, 26, 35, 48, 56, 20, 48, 54, 43, 24, 48, 29, 43, 24, 1, 44, 45, 27, 62, 41, 30, 32, 69, 39, 45, 45, 42, 22, 43, 25, 7, 32, 38, 49, 42, 50, 53, 61, 45, 53, 52, 50, 40, 56, 31, 47, 27, 46, 51, 18, 35, 23, 25, 35, 37, 49, 38, 44, 36, 35, 54, 28, 59, 48, 34, 42, 57, 39, 44, 49, 42, 47, 40, 37, 35, 59, 3, 55, 43, 32, 60, 17, 15, 39, 34, 28, 52, 21, 39, 32, 61, 50, 57, 46, 58, 52, 49, 43, 34, 30, 25, 69, 58, 28, 34, 40, 25, 40, 25, 42, 42, 35, 42, 30, 33, 19, 38, 49, 65, 45, 57, 6, 32, 45, 48, 73, 26, 47, 28, 66, 36, 38, 44, 53, 29, 48, 40, 59, 47, 53, 43, 39, 55, 59, 42, 33, 45, 47, 30, 30, 30, 40, 57, 63, 48, 50, 69, 56, 40, 37, 31, 55, 75, 47, 18, 34, 35, 46, 19, 20, 25, 47, 13, 32, 57, 40, 24, 38, 16, 46, 9, 24, 44, 51, 46, 25, 54, 17, 33, 41, 21, 50, 45, 48, 33, 32, 35, 33, 43, 18, 56, 61, 83, 48, 21, 36, 73, 34, 32, 38, 19, 55, 37, 62, 61, 47, 74, 47, 41, 31, 47, 52, 81, 54, 42, 47, 45, 61, 25, 36, 57, 27, 42, 61, 35, 52, 87, 61, 21, 20, 28, 50, 20, 23, 57, 67, 64, 17, 38, 42, 18, 47, 34, 64, 22, 41, 44, 38, 19, 12, 31, 36, 45, 49, 54, 40, 29, 26, 33, 39, 36, 43, 32, 34, 32, 13, 37, 45, 67, 36, 43, 53, 19, 53, 33, 29, 36, 47, 45, 47, 21, 34, 23, 43, 26, 16, 35, 48, 31, 47, 53, 34, 31, 65, 50, 47, 18, 8, 38, 48, 40, 27, 46, 55, 22, 23, 62, 29, 50, 20, 64, 51, 46, 49, 40, 27, 47, 31, 33, 28, 42, 52, 41, 33, 25, 33, 27, 23, 52, 43, 47, 7, 14, 41, 50, 33, 38, 20, 49, 39, 55, 47, 43, 22, 24, 63, 29, 65, 24, 27, 21, 57, 34, 42, 29, 28, 74, 31, 25, 45, 26, 10, 45, 5, 35, 15, 33, 18, 27, 58, 51, 48, 18, 56, 34, 44, 48, 36, 49, 87, 48, 57, 35, 23, 51, 24, 33, 34, 39, 42, 20, 37, 47, 52, 31, 27, 12, 41, 37, 80, 33, 61, 79, 71, 47, 70, 60, 60, 29, 42, 50, 27, 32, 57, 41, 27, 31, 62, 37, 30, 53, 46, 40, 33, 62, 39, 31, 74, 25, 55, 36, 71, 59, 28, 8, 28, 23, 53, 13, 31, 10, 56, 50, 43, 22, 53, 63, 33, 34, 50, 30, 34, 38, 36, 29, 31, 22, 42, 74, 37, 50, 39, 42, 29, 62, 38, 16, 58, 18, 49, 58, 50, 23, 36, 36, 53, 47, 57, 77, 45, 44, 11, 32, 22, 48, 49, 25, 61, 59, 69, 21, 44, 69, 45, 41, 22, 44, 40, 53, 43, 27, 46, 21, 47, 26, 24, 35, 38, 46, 59, 66, 48, 45, 42, 36, 47, 45, 18, 49, 5, 27, 33, 58, 78, 16, 23, 19, 34, 16, 46, 48, 36, 28, 56, 49, 53, 43, 27, 42, 41, 39, 23, 24, 20, 30, 12, 68, 30, 59, 29, 17, 29, 39, 51, 47, 59, 50, 52, 23, 18, 78, 67, 16, 50, 49, 19, 55, 31, 47, 50, 66, 45, 35, 33, 39, 42, 42, 49, 42, 62, 46, 56, 31, 43, 36, 38, 34, 61, 50, 55, 42, 34, 31, 38, 21, 52, 33, 65, 46, 26, 55, 35, 19, 60, 69, 47, 24, 22, 45, 40, 43, 66, 49, 32, 21, 15, 51, 50, 20, 69, 15, 36, 31, 49, 18, 41, 21, 48, 18, 47, 11, 46, 45, 19, 60, 53, 28, 15, 24, 47, 49, 40, 40, 65, 56, 54, 61, 61, 25, 39, 61, 30, 47, 49, 31, 27, 23, 51, 37, 47, 46, 36, 19, 45, 22, 46, 31, 48, 8, 44, 20, 15, 12, 52, 30, 24, 40, 19, 54, 70, 58, 55, 25, 48, 49, 49, 23, 60, 23, 44, 39, 28, 57, 55, 58, 44, 27, 36, 53, 32, 18, 36, 58, 41, 25, 43, 46, 18, 40, 35, 55, 46, 37, 23, 16, 56, 26, 32, 34, 61, 68, 48, 43, 35, 40, 51, 30, 22, 41, 25, 43, 63, 44, 50, 27, 38, 32, 30, 20, 46, 63, 6, 50, 32, 47, 59, 29, 48, 30, 72, 19, 41, 34, 21, 24, 29, 43, 46, 36, 68, 37, 41, 66, 52, 19, 50, 36, 26, 26, 41, 19, 48, 71, 37, 72, 22, 42, 54, 33, 20, 63, 56, 30, 44, 44, 49, 60, 45, 63, 14, 44, 40, 66, 36, 22, 46, 13, 42, 27, 9, 63, 48, 73, 38, 32, 9, 28, 60, 53, 50, 39, 36, 51, 37, 59, 49, 53, 37, 44, 48, 42, 29, 65, 37, 54, 35, 22, 10, 40, 36, 35, 25, 43, 59, 4, 33, 18, 23, 50, 33, 60, 48, 27, 18, 47, 55, 51, 63, 45, 56, 50, 57, 44, 22, 55, 34, 48, 43, 39, 27, 41, 31, 33, 21, 27, 34, 29, 37, 27, 48, 44, 55, 55, 33, 51, 52, 70, 51, 29, 71, 42, 51, 49, 27, 35, 36, 38, 43, 38, 59, 50, 52, 33, 54, 62, 28, 41, 23, 44, 25, 21, 61, 54, 35, 19, 54, 31, 38, 21, 50, 46, 26, 47, 46, 32, 48, 48, 39, 37, 24, 33, 19, 51, 34, 51, 27, 56, 35, 34, 33, 57, 33, 10, 48, 30, 49, 61, 37, 70, 40, 35, 35, 30, 27, 52, 38, 52, 57, 36, 43, 15, 27, 50, 55, 14, 37, 40, 71, 69, 26, 43, 31, 47, 43, 41, 44, 24, 17, 29, 64, 26, 27, 82, 17, 35, 53, 16, 22, 20, 34, 52, 32, 50, 51, 17, 28, 34, 42, 58, 23, 28, 30, 69, 37, 57, 52, 41, 29, 40, 58, 63, 66, 24, 39, 88, 44, 50, 31, 15, 51, 68, 24, 34, 34, 37, 51, 27, 64, 34, 50, 40, 43, 42, 47, 39, 30, 23, 23, 23, 51, 39, 27, 46, 64, 49, 50, 15, 15, 31, 29, 33, 50, 52, 24, 45, 41, 52, 61, 30, 40, 34, 51, 46, 36, 17, 50, 27, 47, 52, 54, 23, 64, 48, 40, 57, 11, 49, 29, 23, 62, 43, 66, 24, 16, 57, 10, 16, 20, 57, 23, 52, 34, 46, 29, 57, 48, 37, 45, 13, 47, 41, 42, 45, 65, 18, 50, 43, 40, 52, 49, 52, 29, 43, 37, 57, 79, 45, 51, 68, 33, 36, 30, 42, 37, 66, 40, 42, 44, 34, 59, 36, 34, 26, 44, 32, 36, 53, 44, 50, 24, 32, 13, 33, 23, 33, 35, 32, 49, 38, 54, 17, 39, 20, 45, 77, 53, 69, 22, 56, 50, 10, 44, 38, 56, 62, 35, 47, 65, 37, 58, 38, 31, 57, 22, 46, 19, 21, 55, 53, 39, 29, 45, 26, 49, 40, 41, 34, 36, 10, 51, 49, 40, 34, 16, 51, 26, 51, 24, 36, 42, 45, 56, 30, 36, 42, 22, 27, 32, 45, 50, 43, 61, 33, 56, 38, 38, 48, 37, 31, 14, 37, 17, 13, 37, 55, 13, 56, 34, 43, 33, 23, 29, 48, 51, 32, 18, 41, 32, 37, 53, 36, 49, 22, 38, 40, 28, 62, 43, 42, 40, 31, 36, 58, 29, 44, 35, 46, 37, 42, 43, 39, 53, 37, 35, 31, 42, 20, 24, 52, 37, 42, 66, 43, 12, 61, 17, 46, 34, 14, 45, 22, 22, 44, 15, 29, 51, 43, 50, 31, 30, 42, 45, 39, 55, 35, 50, 45, 66, 43, 54, 47, 45, 30, 37, 39, 24, 26, 34, 47, 42, 38, 64, 32, 28, 32, 33, 32, 36, 36, 27, 23, 62, 29, 62, 48, 39, 27, 58, 33, 35, 58, 50, 29, 24, 34, 69, 28, 19, 29, 26, 28, 28, 46, 79, 40, 61, 81, 66, 63, 68, 47, 24, 52, 17, 40, 22, 19, 20, 20, 44, 33, 66, 39, 32, 45, 17, 14, 44, 45, 34, 47, 58, 40, 64, 35, 31, 31, 39, 28, 38, 48, 43, 23, 22, 35, 45, 37, 41, 40, 20, 22, 33, 11, 45, 44, 58, 35, 48, 38, 53, 50, 27, 34, 23, 40, 39, 55, 70, 40, 17, 51, 28, 22, 34, 24, 21, 61, 50, 44, 64, 26, 58, 23, 63, 57, 40, 25, 27, 21, 37, 37, 46, 36, 41, 35, 73, 33, 26, 15, 14, 8, 43, 57, 29, 38, 49, 22, 34, 70, 41, 42, 37, 35, 28, 25, 37, 25, 29, 39, 42, 26, 47, 67, 11, 58, 50, 44, 21, 44, 31, 62, 30, 25, 35, 58, 40, 79, 19, 35, 54, 23, 55, 30, 51, 47, 33, 65, 36, 26, 33, 37, 33, 54, 31, 61, 59, 45, 49, 58, 31, 6, 24, 9, 41, 68, 35, 43, 64, 34, 76, 42, 43, 39, 60, 37, 38, 14, 40, 42, 65, 76, 56, 67, 43, 39, 45, 33, 21, 21, 41, 15, 9, 15, 49, 57, 58, 46, 58, 68, 21, 79, 51, 70, 19, 26, 37, 42, 51, 32, 16, 32, 15, 57, 36, 72, 43, 29, 28, 57, 42, 54, 19, 28, 46, 34, 47, 43, 57, 60, 54, 34, 41, 60, 30, 58, 48, 37, 48, 56, 64, 63, 57, 30, 44, 60, 48, 50, 32, 68, 52, 59, 69, 40, 34, 51, 79, 21, 47, 60, 65, 27, 50, 22, 38, 40, 41, 7, 59, 59, 24, 24, 55, 48, 43, 41, 37, 56, 55, 26, 51, 35, 33, 48, 33, 42, 40, 41, 52, 37, 14, 67, 34, 3, 14, 82, 58, 32, 46, 49, 59, 44, 18, 27, 34, 49, 63, 49, 16, 26, 61, 38, 42, 12, 13, 54, 18, 33, 38, 53, 38, 38, 34, 49, 40, 42, 26, 18, 28, 33, 30, 45, 47, 12, 60, 37, 73, 61, 31, 6, 37, 27, 21, 26, 39, 37, 30, 35, 60, 38, 49, 32, 74, 30, 43, 74, 29, 34, 51, 51, 33, 29, 41, 36, 33, 65, 49, 32, 56, 22, 41, 53, 59, 27, 27, 38, 35, 37, 42, 63, 45, 35, 61, 53, 37, 57, 44, 32, 24, 40, 40, 37, 53, 48, 18, 40, 62, 49, 65, 16, 24, 64, 55, 37, 50, 60, 49, 41, 70, 50, 41, 26, 46, 41, 30, 43, 40, 32, 41, 31, 31, 20, 41, 28, 22, 59, 36, 38, 42, 38, 16, 59, 52, 49, 26, 34, 43, 24, 20, 48, 39, 14, 25, 24, 29, 43, 37, 50, 20, 43, 71, 53, 39, 52, 29, 35, 55, 43, 30, 70, 16, 49, 59, 44, 47, 34, 56, 53, 29, 41, 46, 40, 39, 28, 23, 26, 36, 61, 41, 38, 46, 49, 34, 36, 14, 34, 48, 21, 33, 22, 35, 51, 35, 14, 54, 53, 41, 52, 48, 39, 36, 44, 36, 41, 45, 56, 32, 21, 64, 48, 24, 32, 29, 33, 34, 38, 41, 54, 33, 27, 29, 59, 43, 37, 27, 50, 25, 38, 23, 61, 47, 48, 60, 45, 30, 14, 35, 57, 39, 29, 40, 32, 40, 43, 47, 33, 47, 42, 34, 50, 23, 24, 26, 31, 28, 49, 30, 56, 9, 30, 30, 45, 17, 54, 58, 16, 17, 39, 32, 53, 38, 23, 46, 33, 12, 39, 31, 44, 46, 62, 35, 68, 45, 54, 47, 30, 50, 43, 60, 44, 12, 50, 28, 60, 66, 45, 38, 50, 31, 26, 40, 25, 25, 31, 54, 50, 53, 23, 18, 54, 53, 49, 66, 52, 12, 28, 60, 25, 54, 72, 48, 33, 46, 44, 44, 37, 54, 63, 33, 41, 32, 43, 35, 79, 52, 41, 68, 22, 53, 29, 31, 43, 43, 63, 37, 44, 43, 17, 36, 34, 58, 54, 54, 26, 27, 26, 49, 22, 51, 39, 57, 31, 32, 8, 44, 16, 23, 30, 51, 27, 54, 37, 32, 55, 41, 25, 39, 54, 15, 22, 47, 34, 61, 27, 53, 45, 44, 35, 41, 52, 42, 39, 45, 65, 61, 67, 43, 40, 38, 43, 44, 31, 35, 63, 57, 47, 28, 21, 36, 57, 54, 52, 32, 53, 23, 62, 22, 33, 32, 48, 39, 43, 20, 49, 51, 54, 46, 31, 41, 12, 49, 20, 36, 37, 62, 32, 33, 31, 34, 52, 35, 62, 24, 50, 52, 25, 8, 31, 22, 60, 52, 33, 57, 63, 59, 42, 28, 50, 25, 35, 56, 70, 65, 64, 46, 55, 16, 21, 44, 51, 39, 62, 46, 50, 53, 26, 24, 32, 26, 62, 17, 36, 55, 42, 50, 44, 43, 45, 22, 19, 62, 18, 35, 56, 27, 47, 42, 47, 7, 42, 29, 49, 50, 52, 42, 17, 53, 41, 53, 42, 45, 54, 63, 56, 23, 57, 45, 34, 29, 34, 14, 38, 42, 38, 43, 57, 32, 23, 42, 25, 16, 28, 39, 30, 54, 36, 32, 52, 83, 80, 35, 19, 23, 23, 34, 20, 46, 20, 57, 52, 34, 50, 48, 40, 51, 51, 65, 37, 8, 43, 40, 35, 38, 61, 22, 41, 56, 62, 30, 51, 29, 29, 51, 35, 39, 39, 28, 18, 53, 22, 47, 5, 30, 34, 30, 71, 57, 44, 58, 43, 56, 36, 38, 24, 33, 43, 28, 51, 36, 43, 68, 37, 49, 41, 9, 33, 42, 68, 45, 24, 50, 67, 47, 66, 50, 43, 15, 69, 42, 25, 48, 65, 37, 42, 65, 31, 45, 27, 34, 41, 68, 40, 21, 33, 19, 51, 39, 15, 19, 48, 53, 40, 83, 8, 50, 59, 47, 52, 60, 43, 57, 37, 49, 45, 52, 57, 10, 53, 25, 32, 58, 40, 33, 44, 32, 36, 44, 39, 19, 40, 54, 21, 48, 51, 37, 58, 14, 40, 55, 74, 37, 33, 30, 39, 72, 40, 34, 15, 34, 60, 55, 42, 38, 44, 51, 43, 12, 44, 43, 46, 15, 73, 37, 25, 9, 67, 30, 39, 59, 36, 19, 57, 31, 29, 36, 23, 13, 32, 50, 25, 39, 57, 48, 28, 45, 52, 31, 37, 53, 33, 47, 24, 33, 36, 62, 38, 29, 80, 27, 54, 42, 27, 61, 48, 13, 61, 53, 46, 19, 28, 42, 49, 43, 50, 34, 35, 17, 24, 44, 57, 17, 15, 21, 45, 25, 40, 38, 27, 31, 35, 46, 23, 25, 31, 61, 19, 38, 50, 29, 34, 36, 55, 34, 48, 68, 37, 37, 80, 26, 31, 23, 52, 26, 42, 20, 22, 61, 20, 42, 28, 34, 51, 38, 71, 60, 39, 39, 27, 34, 37, 14, 50, 38, 58, 55, 43, 20, 33, 44, 39, 32, 12, 35, 36, 53, 23, 23, 29, 14, 45, 53, 53, 61, 22, 78, 39, 46, 40, 60, 64, 39, 32, 32, 43, 13, 40, 15, 36, 55, 67, 39, 15, 29, 29, 56, 44, 66, 43, 50, 31, 40, 37, 54, 39, 42, 40, 25, 17, 32, 38, 59, 38, 26, 28, 7, 28, 60, 24, 36, 41, 45, 41, 22, 43, 40, 26, 24, 44, 39, 21, 38, 44, 44, 51, 25, 65, 59, 34, 27, 47, 43, 45, 14, 42, 20, 31, 16, 31, 35, 36, 45, 52, 48, 32, 40, 58, 27, 30, 23, 53, 25, 48, 35, 75, 13, 36, 38, 39, 49, 69, 20, 41, 58, 26, 45, 48, 17, 29, 49, 38, 27, 45, 17, 40, 68, 16, 17, 41, 50, 26, 20, 28, 36, 23, 27, 39, 46, 25, 24, 47, 60, 44, 47, 29, 25, 58, 36, 39, 53, 33, 35, 48, 41, 39, 34, 16, 64, 50, 45, 53, 16, 37, 59, 51, 50, 30, 59, 20, 15, 39, 65, 40, 25, 36, 53, 40, 57, 42, 48, 66, 26, 51, 25, 41, 75, 54, 34, 52, 15, 56, 41, 49, 42, 26, 26, 33, 64, 46, 45, 14, 33, 60, 26, 59, 58, 53, 27, 51, 15, 41, 10, 33, 22, 31, 48, 21, 51, 27, 18, 37, 49, 51, 37, 68, 21, 35, 69, 42, 29, 41, 34, 64, 15, 28, 35, 38, 50, 50, 34, 62, 59, 27, 53, 23, 43, 48, 33, 15, 55, 40, 54, 37, 34, 31, 26, 50, 28, 44, 22, 59, 43, 40, 47, 34, 61, 34, 44, 42, 54, 57, 50, 46, 37, 21, 26, 39, 61, 33, 37, 45, 28, 44, 20, 50, 24, 40, 36, 44, 44, 44, 22, 73, 49, 18, 16, 39, 61, 31, 48, 20, 27, 59, 31, 45, 43, 32, 46, 29, 46, 16, 28, 35, 45, 42, 32, 29, 69, 35, 43, 25, 56, 53, 31, 34, 21, 60, 30, 59, 41, 42, 59, 49, 37, 30, 28, 61, 17, 52, 23, 33, 34, 36, 19, 45, 46, 27, 25, 33, 38, 50, 24, 19, 34, 51, 35, 38, 33, 36, 34, 25, 34, 33, 39, 20, 56, 30, 26, 27, 42, 65, 42, 55, 38, 38, 43, 45, 43, 9, 51, 58, 34, 39, 64, 42, 20, 47, 26, 26, 22, 47, 46, 41, 49, 19, 46, 73, 41, 32, 19, 57, 65, 22, 17, 26, 26, 46, 66, 47, 61, 70, 38, 42, 56, 34, 36, 52, 34, 59, 66, 69, 58, 29, 48, 21, 48, 50, 28, 42, 30, 55, 42, 39, 69, 50, 76, 55, 54, 40, 58, 39, 54, 31, 39, 50, 32, 49, 45, 61, 39, 38, 45, 49, 52, 43, 27, 19, 59, 35, 23, 55, 34, 32, 61, 22, 33, 51, 23, 17, 52, 62, 59, 54, 48, 24, 27, 22, 58, 28, 29, 7, 33, 60, 50, 56, 10, 11, 42, 35, 56, 53, 18, 37, 24, 70, 28, 35, 35, 13, 23, 46, 19, 29, 52, 49, 55, 45, 28, 47, 37, 40, 42, 67, 28, 37, 16, 27, 43, 41, 40, 54, 60, 38, 45, 65, 21, 33, 55, 34, 44, 29, 45, 34, 65, 60, 10, 44, 28, 21, 53, 54, 48, 41, 34, 41, 32, 42, 18, 31, 22, 45, 54, 44, 49, 22, 37, 41, 59, 32, 35, 37, 38, 66, 49, 53, 30, 31, 18, 49, 14, 56, 40, 27, 18, 16, 16, 31, 66, 46, 41, 21, 54, 51, 51, 42, 43, 31, 36, 32, 17, 35, 30, 29, 38, 47, 32, 13, 57, 45, 35, 60, 38]}, 'test_1': {'capacity': 100, 'num_items': 5000, 'items': [42, 57, 41, 42, 43, 30, 26, 21, 42, 24, 37, 52, 50, 32, 76, 58, 69, 35, 30, 42, 40, 28, 63, 60, 42, 46, 38, 39, 45, 43, 53, 72, 26, 41, 39, 19, 63, 43, 32, 29, 48, 33, 29, 17, 44, 13, 57, 48, 12, 60, 51, 27, 55, 40, 22, 63, 37, 53, 34, 25, 41, 54, 36, 46, 43, 44, 41, 42, 20, 35, 31, 32, 72, 36, 20, 26, 26, 65, 48, 31, 71, 43, 46, 36, 33, 52, 32, 35, 56, 35, 29, 36, 61, 50, 66, 36, 29, 13, 60, 43, 40, 66, 49, 28, 48, 23, 35, 55, 84, 50, 50, 39, 33, 45, 42, 40, 27, 26, 21, 54, 30, 59, 18, 41, 52, 8, 19, 64, 41, 38, 50, 53, 65, 20, 15, 18, 36, 27, 27, 30, 43, 10, 33, 55, 26, 28, 48, 50, 36, 43, 39, 42, 48, 8, 46, 21, 15, 59, 33, 41, 40, 46, 44, 33, 42, 30, 32, 57, 30, 32, 30, 30, 41, 77, 49, 14, 54, 56, 68, 53, 24, 31, 29, 43, 22, 16, 26, 47, 18, 46, 29, 13, 47, 33, 44, 40, 60, 22, 66, 55, 37, 41, 37, 32, 37, 53, 77, 42, 28, 35, 32, 28, 27, 63, 36, 38, 61, 40, 17, 66, 53, 45, 55, 24, 3, 45, 53, 43, 59, 70, 45, 33, 68, 44, 39, 64, 56, 27, 42, 24, 54, 61, 51, 34, 58, 44, 44, 45, 56, 38, 40, 14, 57, 51, 25, 15, 35, 57, 51, 45, 16, 30, 29, 31, 45, 35, 47, 20, 20, 20, 34, 57, 61, 37, 34, 23, 31, 40, 46, 49, 59, 41, 39, 42, 23, 44, 29, 32, 31, 35, 19, 20, 54, 12, 35, 53, 40, 70, 39, 31, 43, 38, 28, 33, 38, 50, 33, 19, 30, 60, 45, 30, 43, 39, 47, 40, 33, 32, 15, 26, 53, 51, 63, 27, 55, 34, 56, 26, 56, 52, 42, 45, 39, 35, 65, 47, 33, 26, 50, 63, 24, 32, 34, 24, 47, 51, 66, 45, 42, 30, 49, 57, 40, 21, 21, 43, 31, 42, 33, 11, 75, 46, 40, 43, 34, 43, 38, 56, 42, 28, 51, 27, 44, 51, 28, 53, 41, 27, 27, 36, 50, 48, 56, 68, 28, 45, 54, 56, 33, 49, 26, 29, 33, 30, 53, 39, 26, 51, 19, 39, 27, 29, 56, 32, 40, 55, 40, 21, 32, 32, 19, 18, 54, 41, 27, 46, 43, 31, 17, 46, 31, 39, 39, 56, 34, 40, 23, 32, 28, 38, 21, 50, 51, 21, 37, 28, 35, 34, 48, 10, 45, 46, 62, 10, 24, 56, 60, 46, 54, 42, 47, 40, 20, 58, 45, 41, 16, 25, 72, 58, 42, 55, 36, 39, 31, 34, 6, 53, 52, 31, 46, 43, 24, 78, 56, 12, 43, 30, 59, 38, 48, 32, 11, 33, 36, 22, 53, 34, 70, 45, 40, 38, 30, 31, 70, 46, 20, 72, 35, 22, 32, 39, 44, 58, 34, 32, 41, 81, 52, 62, 27, 50, 29, 51, 40, 37, 48, 50, 48, 45, 9, 16, 33, 42, 50, 66, 16, 12, 77, 21, 58, 22, 38, 12, 27, 57, 19, 61, 41, 33, 25, 35, 61, 60, 66, 22, 56, 59, 34, 35, 38, 53, 53, 40, 36, 13, 27, 25, 35, 35, 66, 41, 64, 47, 62, 50, 36, 48, 33, 41, 39, 45, 49, 35, 63, 37, 16, 42, 35, 45, 24, 48, 35, 48, 21, 14, 22, 63, 26, 23, 40, 59, 48, 58, 44, 32, 69, 72, 41, 41, 51, 15, 29, 22, 42, 49, 40, 35, 48, 18, 29, 23, 25, 28, 54, 19, 13, 67, 37, 43, 31, 13, 46, 30, 29, 47, 48, 46, 49, 31, 38, 40, 54, 39, 49, 49, 50, 16, 20, 33, 46, 59, 33, 46, 49, 36, 41, 32, 44, 52, 49, 76, 32, 42, 45, 52, 47, 38, 21, 49, 22, 63, 35, 34, 51, 42, 73, 30, 62, 55, 25, 56, 51, 48, 49, 51, 52, 24, 55, 50, 25, 17, 30, 31, 33, 25, 47, 29, 38, 16, 28, 35, 51, 40, 4, 52, 15, 30, 27, 41, 43, 72, 21, 52, 47, 22, 51, 71, 29, 62, 38, 26, 64, 19, 32, 49, 39, 47, 56, 39, 51, 36, 51, 36, 57, 79, 41, 40, 47, 30, 31, 54, 45, 16, 22, 40, 46, 23, 27, 53, 53, 33, 19, 9, 11, 56, 45, 34, 37, 53, 50, 36, 48, 49, 40, 49, 32, 45, 19, 48, 33, 33, 36, 52, 32, 50, 27, 31, 19, 30, 21, 54, 68, 64, 28, 56, 8, 55, 34, 22, 54, 30, 60, 37, 29, 18, 20, 10, 17, 19, 27, 41, 35, 34, 55, 28, 51, 35, 22, 47, 41, 44, 46, 28, 20, 22, 28, 47, 50, 86, 43, 50, 20, 13, 55, 54, 45, 50, 51, 21, 53, 42, 45, 46, 39, 48, 47, 35, 14, 29, 29, 56, 57, 51, 42, 21, 40, 26, 55, 41, 32, 37, 16, 58, 52, 42, 58, 35, 61, 38, 15, 54, 8, 44, 47, 30, 69, 36, 42, 27, 28, 45, 45, 68, 18, 50, 55, 21, 32, 36, 33, 48, 29, 42, 23, 65, 37, 31, 25, 37, 52, 39, 11, 26, 51, 80, 35, 37, 40, 40, 31, 67, 35, 36, 41, 72, 34, 64, 17, 35, 44, 22, 37, 67, 49, 65, 53, 52, 40, 34, 35, 22, 43, 17, 43, 56, 46, 31, 16, 39, 39, 47, 58, 47, 43, 32, 18, 42, 48, 61, 46, 37, 46, 61, 57, 41, 29, 34, 17, 53, 18, 51, 44, 38, 55, 44, 59, 32, 64, 19, 30, 12, 34, 45, 35, 26, 20, 33, 9, 12, 52, 29, 23, 28, 28, 59, 34, 30, 51, 45, 9, 22, 34, 33, 17, 29, 45, 13, 15, 24, 51, 24, 48, 27, 33, 53, 28, 16, 34, 35, 37, 11, 57, 17, 59, 30, 36, 60, 69, 48, 33, 32, 35, 50, 29, 34, 55, 12, 28, 12, 42, 33, 50, 62, 14, 61, 50, 43, 56, 22, 45, 32, 26, 63, 19, 6, 24, 28, 25, 31, 38, 48, 73, 49, 29, 16, 37, 50, 54, 56, 19, 61, 47, 31, 28, 42, 66, 45, 75, 55, 27, 13, 16, 49, 26, 28, 66, 24, 35, 59, 38, 47, 23, 19, 34, 30, 49, 36, 48, 25, 5, 27, 46, 46, 22, 54, 9, 61, 17, 41, 43, 34, 29, 56, 44, 38, 36, 23, 31, 60, 44, 23, 38, 33, 20, 28, 28, 56, 45, 25, 40, 51, 55, 38, 36, 48, 45, 62, 66, 58, 30, 36, 40, 55, 36, 51, 57, 24, 49, 32, 29, 26, 45, 33, 39, 36, 55, 21, 17, 23, 38, 26, 72, 48, 46, 40, 58, 36, 39, 45, 31, 31, 48, 69, 22, 18, 65, 47, 56, 51, 32, 37, 29, 30, 38, 32, 30, 34, 34, 38, 46, 35, 33, 28, 54, 53, 78, 35, 60, 48, 32, 22, 35, 47, 20, 24, 20, 35, 50, 36, 58, 29, 40, 45, 22, 20, 27, 77, 24, 40, 31, 45, 50, 57, 47, 42, 34, 42, 48, 64, 43, 35, 44, 21, 26, 48, 32, 32, 22, 38, 30, 35, 40, 64, 32, 49, 28, 15, 43, 54, 22, 61, 45, 45, 39, 48, 39, 74, 52, 55, 50, 51, 42, 32, 29, 28, 13, 42, 39, 53, 48, 35, 45, 31, 38, 39, 26, 54, 23, 45, 30, 58, 31, 29, 47, 19, 74, 22, 41, 20, 70, 25, 32, 62, 16, 22, 64, 17, 50, 24, 49, 33, 20, 54, 15, 32, 67, 57, 38, 65, 35, 50, 55, 51, 23, 65, 31, 53, 36, 34, 49, 65, 32, 62, 33, 49, 52, 33, 47, 29, 36, 45, 24, 44, 30, 71, 32, 37, 36, 48, 48, 23, 36, 55, 23, 30, 37, 30, 48, 22, 39, 25, 27, 49, 34, 28, 33, 52, 55, 36, 60, 29, 44, 52, 48, 55, 16, 51, 41, 35, 30, 48, 33, 55, 24, 56, 50, 36, 49, 15, 37, 64, 56, 41, 15, 38, 21, 31, 61, 54, 32, 52, 41, 65, 41, 53, 37, 35, 23, 56, 40, 53, 11, 34, 53, 27, 48, 47, 80, 20, 57, 64, 44, 56, 26, 10, 31, 21, 32, 19, 26, 42, 27, 43, 59, 20, 70, 47, 17, 42, 13, 40, 45, 13, 47, 32, 42, 39, 63, 22, 30, 67, 63, 65, 37, 32, 53, 36, 43, 50, 12, 37, 39, 29, 35, 41, 40, 44, 50, 62, 33, 49, 43, 27, 46, 43, 13, 49, 49, 19, 42, 34, 44, 61, 59, 27, 30, 33, 45, 20, 21, 66, 47, 51, 49, 49, 32, 20, 74, 33, 66, 49, 45, 33, 29, 32, 18, 7, 37, 64, 43, 65, 25, 35, 45, 30, 31, 58, 29, 20, 9, 35, 13, 26, 41, 24, 50, 20, 64, 39, 35, 68, 40, 54, 48, 48, 67, 43, 51, 38, 35, 50, 65, 30, 46, 64, 27, 7, 46, 68, 53, 37, 66, 37, 3, 65, 50, 38, 31, 32, 29, 64, 34, 21, 32, 47, 27, 38, 31, 50, 54, 55, 34, 30, 24, 37, 42, 26, 24, 30, 46, 54, 29, 34, 39, 36, 16, 57, 50, 25, 21, 37, 43, 39, 40, 49, 44, 46, 13, 28, 41, 62, 32, 36, 30, 56, 37, 38, 72, 6, 47, 39, 37, 74, 36, 53, 31, 34, 28, 27, 47, 45, 54, 23, 50, 28, 49, 43, 45, 65, 21, 17, 35, 21, 16, 20, 47, 17, 45, 29, 24, 61, 50, 28, 26, 46, 18, 40, 27, 42, 46, 48, 24, 36, 23, 61, 55, 62, 56, 28, 36, 73, 61, 48, 41, 6, 18, 46, 48, 38, 48, 68, 26, 41, 28, 54, 36, 58, 27, 49, 40, 16, 44, 69, 36, 23, 35, 45, 55, 58, 39, 24, 43, 32, 45, 46, 50, 30, 44, 61, 57, 37, 45, 72, 33, 30, 50, 28, 23, 26, 36, 51, 36, 44, 37, 27, 38, 29, 47, 55, 27, 31, 17, 36, 53, 74, 44, 47, 36, 37, 35, 54, 26, 52, 34, 31, 49, 61, 27, 31, 29, 21, 47, 69, 49, 27, 49, 44, 41, 60, 57, 48, 48, 65, 50, 41, 53, 26, 47, 38, 22, 18, 44, 23, 52, 48, 45, 41, 18, 38, 42, 21, 45, 72, 46, 35, 49, 54, 54, 20, 43, 42, 63, 45, 38, 14, 22, 55, 51, 37, 12, 52, 38, 20, 43, 45, 78, 24, 21, 23, 20, 29, 24, 37, 46, 38, 22, 38, 33, 40, 31, 30, 25, 50, 14, 47, 29, 20, 56, 20, 42, 35, 44, 49, 68, 34, 15, 46, 40, 31, 57, 28, 35, 37, 16, 46, 12, 67, 39, 21, 23, 41, 59, 50, 13, 36, 73, 41, 29, 44, 45, 47, 59, 72, 51, 61, 23, 22, 27, 55, 37, 12, 57, 37, 67, 36, 17, 50, 29, 39, 41, 39, 32, 46, 47, 41, 42, 67, 45, 28, 37, 37, 59, 55, 51, 35, 18, 48, 46, 82, 35, 40, 62, 46, 20, 11, 50, 40, 11, 32, 35, 26, 63, 36, 35, 45, 61, 43, 50, 19, 17, 54, 55, 51, 35, 52, 38, 62, 37, 53, 40, 56, 25, 14, 36, 48, 56, 36, 19, 31, 45, 28, 52, 36, 40, 82, 33, 42, 50, 33, 19, 28, 13, 67, 63, 28, 44, 21, 85, 21, 34, 23, 60, 37, 53, 33, 49, 49, 56, 75, 37, 52, 37, 58, 42, 39, 31, 24, 54, 37, 29, 60, 58, 42, 27, 31, 53, 42, 43, 54, 47, 19, 26, 19, 45, 24, 30, 41, 26, 31, 46, 7, 48, 40, 47, 34, 30, 32, 33, 61, 48, 34, 48, 38, 51, 33, 22, 40, 49, 36, 46, 54, 64, 61, 50, 47, 44, 65, 65, 47, 31, 28, 30, 45, 43, 36, 51, 44, 66, 49, 19, 23, 45, 35, 17, 18, 37, 52, 27, 24, 52, 34, 51, 31, 63, 38, 36, 38, 30, 26, 9, 46, 54, 26, 29, 49, 23, 46, 40, 19, 23, 46, 29, 44, 46, 20, 15, 25, 30, 63, 60, 38, 30, 38, 35, 33, 35, 39, 51, 22, 34, 26, 26, 17, 34, 9, 21, 17, 23, 41, 18, 15, 44, 41, 30, 57, 43, 36, 40, 44, 32, 35, 44, 16, 41, 27, 46, 58, 47, 47, 25, 32, 42, 37, 22, 29, 21, 46, 33, 40, 77, 34, 18, 37, 33, 51, 65, 36, 38, 59, 48, 40, 22, 41, 17, 44, 39, 44, 22, 28, 41, 41, 62, 52, 41, 45, 54, 62, 39, 59, 48, 19, 54, 40, 45, 30, 33, 49, 26, 51, 42, 54, 48, 38, 33, 41, 27, 49, 51, 80, 29, 43, 56, 17, 29, 30, 32, 34, 41, 19, 38, 50, 15, 34, 54, 12, 24, 58, 31, 69, 26, 49, 52, 37, 55, 32, 46, 47, 54, 27, 33, 30, 36, 38, 28, 69, 43, 50, 45, 58, 59, 21, 41, 16, 41, 33, 16, 57, 28, 16, 13, 42, 19, 45, 52, 37, 23, 60, 27, 77, 32, 50, 49, 59, 44, 27, 46, 28, 53, 61, 15, 21, 43, 45, 42, 25, 64, 18, 64, 37, 35, 71, 51, 39, 23, 13, 3, 21, 71, 27, 37, 37, 71, 22, 58, 55, 46, 52, 69, 44, 30, 60, 14, 31, 32, 54, 48, 59, 30, 2, 21, 28, 22, 39, 7, 42, 39, 52, 57, 14, 13, 46, 37, 40, 33, 24, 60, 28, 54, 33, 49, 22, 23, 33, 23, 43, 53, 47, 40, 22, 18, 39, 41, 29, 62, 28, 49, 27, 45, 38, 30, 75, 25, 31, 45, 54, 17, 33, 18, 37, 38, 63, 46, 44, 45, 69, 42, 32, 46, 49, 36, 24, 45, 50, 18, 45, 44, 49, 23, 30, 57, 10, 87, 38, 66, 50, 44, 33, 17, 60, 58, 53, 32, 38, 48, 20, 31, 56, 43, 52, 35, 48, 37, 21, 24, 44, 42, 58, 28, 54, 56, 48, 28, 46, 73, 38, 62, 46, 44, 64, 40, 22, 54, 38, 41, 47, 47, 58, 19, 49, 28, 52, 41, 23, 31, 56, 32, 38, 53, 15, 21, 73, 58, 21, 34, 24, 22, 37, 39, 57, 16, 58, 42, 50, 71, 24, 41, 51, 33, 59, 18, 12, 24, 39, 33, 15, 73, 66, 47, 20, 27, 29, 31, 7, 44, 19, 31, 45, 34, 39, 38, 53, 67, 49, 52, 37, 40, 54, 36, 40, 31, 53, 27, 42, 40, 43, 29, 30, 22, 43, 78, 38, 30, 30, 24, 42, 63, 52, 6, 13, 12, 44, 27, 17, 50, 19, 36, 46, 45, 59, 61, 58, 59, 37, 22, 39, 44, 14, 58, 71, 74, 51, 41, 41, 49, 39, 45, 28, 33, 23, 36, 28, 43, 13, 28, 48, 44, 40, 59, 50, 29, 41, 72, 22, 16, 44, 44, 47, 39, 45, 58, 29, 68, 47, 59, 13, 51, 14, 45, 39, 49, 57, 47, 58, 70, 53, 28, 37, 52, 53, 42, 42, 45, 54, 56, 82, 38, 55, 30, 33, 53, 44, 64, 33, 38, 37, 19, 38, 37, 53, 46, 25, 46, 13, 29, 50, 61, 49, 56, 53, 61, 30, 34, 47, 54, 22, 13, 50, 42, 30, 16, 16, 38, 40, 18, 24, 16, 44, 30, 52, 44, 29, 50, 34, 64, 8, 42, 41, 55, 55, 57, 32, 23, 16, 41, 40, 37, 27, 10, 52, 69, 24, 40, 55, 35, 47, 30, 40, 46, 40, 10, 24, 30, 36, 73, 26, 28, 29, 60, 64, 54, 52, 53, 33, 33, 40, 23, 51, 66, 62, 55, 37, 30, 24, 40, 71, 17, 50, 31, 23, 38, 35, 46, 32, 50, 42, 47, 48, 36, 47, 29, 22, 41, 60, 66, 57, 18, 20, 61, 38, 17, 40, 31, 42, 47, 44, 60, 9, 33, 37, 34, 62, 49, 27, 44, 22, 25, 52, 44, 46, 18, 42, 46, 16, 31, 21, 35, 31, 67, 46, 32, 38, 40, 42, 39, 23, 20, 28, 21, 34, 22, 33, 60, 49, 52, 25, 46, 59, 48, 55, 45, 38, 40, 28, 43, 7, 39, 80, 34, 15, 32, 38, 68, 42, 52, 61, 70, 28, 54, 50, 52, 45, 35, 39, 27, 29, 65, 35, 24, 52, 8, 32, 62, 29, 51, 48, 37, 54, 29, 45, 33, 31, 69, 33, 14, 35, 39, 30, 29, 64, 64, 12, 24, 16, 40, 53, 49, 39, 52, 40, 29, 52, 60, 50, 51, 44, 18, 65, 58, 28, 51, 61, 56, 53, 21, 34, 62, 63, 59, 35, 44, 46, 56, 48, 32, 52, 25, 34, 33, 40, 16, 17, 42, 46, 51, 40, 43, 31, 68, 24, 49, 37, 31, 38, 24, 29, 65, 12, 53, 63, 32, 7, 41, 32, 26, 35, 42, 25, 29, 28, 46, 56, 34, 50, 9, 53, 29, 14, 48, 61, 33, 46, 40, 6, 65, 26, 65, 30, 43, 22, 27, 48, 60, 32, 21, 63, 30, 55, 54, 29, 65, 23, 20, 41, 52, 22, 28, 48, 33, 22, 55, 43, 64, 73, 45, 49, 53, 17, 71, 31, 56, 44, 35, 39, 32, 53, 38, 32, 40, 49, 58, 25, 46, 11, 30, 35, 43, 40, 40, 38, 27, 41, 31, 34, 58, 33, 21, 54, 66, 53, 26, 62, 27, 13, 59, 9, 48, 20, 34, 29, 27, 50, 69, 36, 28, 18, 22, 34, 51, 28, 66, 30, 55, 53, 50, 43, 60, 28, 31, 24, 34, 47, 26, 36, 16, 38, 47, 51, 65, 36, 34, 14, 40, 17, 55, 23, 33, 44, 27, 62, 59, 31, 6, 43, 19, 63, 21, 32, 61, 26, 39, 12, 35, 33, 48, 7, 41, 58, 47, 15, 45, 51, 59, 43, 56, 33, 26, 40, 50, 57, 31, 46, 27, 62, 39, 44, 45, 36, 46, 37, 44, 43, 35, 45, 53, 10, 7, 45, 33, 23, 29, 30, 35, 66, 34, 66, 37, 54, 30, 23, 48, 62, 60, 45, 68, 42, 50, 47, 51, 22, 43, 52, 40, 46, 46, 14, 7, 35, 33, 18, 52, 56, 18, 63, 43, 18, 49, 61, 58, 32, 33, 15, 12, 38, 47, 15, 39, 38, 44, 52, 47, 44, 58, 23, 23, 47, 38, 40, 66, 28, 19, 22, 25, 21, 38, 39, 57, 45, 14, 38, 23, 62, 25, 69, 30, 52, 29, 20, 51, 40, 30, 42, 36, 25, 48, 47, 54, 8, 23, 59, 32, 78, 50, 27, 42, 28, 33, 40, 29, 32, 21, 39, 59, 69, 42, 40, 16, 51, 27, 45, 38, 42, 66, 38, 26, 28, 44, 51, 54, 65, 39, 70, 29, 42, 48, 41, 51, 48, 51, 23, 58, 33, 43, 35, 50, 54, 38, 40, 43, 74, 29, 56, 55, 40, 20, 47, 43, 23, 45, 12, 50, 42, 56, 22, 32, 10, 26, 47, 54, 21, 8, 37, 34, 32, 42, 41, 15, 28, 58, 19, 35, 34, 47, 8, 30, 68, 21, 41, 25, 18, 60, 60, 48, 59, 56, 32, 32, 86, 17, 64, 51, 60, 19, 47, 41, 39, 23, 23, 62, 36, 41, 35, 49, 27, 28, 60, 11, 55, 35, 38, 14, 62, 28, 12, 55, 11, 34, 27, 46, 55, 31, 51, 24, 66, 49, 51, 39, 55, 21, 43, 40, 36, 39, 65, 38, 29, 46, 33, 27, 27, 26, 19, 25, 29, 30, 23, 50, 44, 19, 35, 34, 67, 51, 38, 53, 22, 42, 21, 61, 43, 28, 44, 12, 27, 36, 61, 40, 61, 39, 54, 30, 25, 44, 17, 54, 55, 29, 34, 31, 48, 39, 41, 61, 33, 62, 46, 36, 9, 45, 32, 54, 59, 48, 51, 37, 35, 33, 36, 53, 51, 46, 49, 18, 59, 27, 42, 50, 26, 52, 35, 26, 37, 47, 37, 41, 48, 54, 35, 40, 35, 24, 34, 33, 43, 44, 17, 45, 26, 56, 29, 43, 45, 14, 16, 42, 54, 31, 49, 59, 68, 16, 20, 63, 52, 47, 51, 64, 39, 49, 41, 65, 38, 30, 34, 9, 26, 32, 27, 20, 39, 71, 49, 16, 39, 52, 49, 64, 37, 33, 26, 46, 19, 51, 36, 51, 20, 49, 63, 67, 68, 48, 14, 51, 54, 43, 36, 41, 18, 39, 44, 61, 36, 40, 29, 35, 32, 63, 41, 21, 35, 43, 28, 53, 55, 67, 57, 35, 54, 57, 52, 33, 63, 25, 34, 57, 77, 45, 57, 30, 51, 44, 53, 42, 51, 33, 34, 63, 41, 45, 35, 40, 48, 25, 53, 48, 50, 37, 37, 55, 52, 30, 44, 35, 41, 51, 45, 42, 35, 35, 23, 34, 28, 37, 38, 63, 61, 52, 67, 52, 41, 63, 39, 33, 56, 39, 50, 63, 42, 29, 41, 38, 59, 10, 52, 56, 53, 39, 41, 43, 68, 49, 33, 43, 41, 40, 38, 20, 42, 48, 30, 65, 22, 49, 40, 34, 62, 30, 32, 28, 40, 44, 40, 2, 68, 35, 31, 48, 44, 13, 79, 27, 22, 51, 40, 28, 31, 57, 54, 47, 20, 61, 20, 26, 53, 25, 48, 27, 23, 40, 54, 24, 57, 22, 73, 25, 44, 42, 40, 52, 18, 17, 34, 40, 30, 35, 30, 46, 35, 46, 15, 18, 19, 28, 46, 81, 53, 42, 48, 36, 61, 25, 40, 25, 34, 66, 34, 29, 48, 39, 53, 40, 31, 28, 57, 45, 33, 12, 28, 21, 53, 47, 50, 38, 54, 44, 26, 27, 10, 46, 33, 46, 53, 50, 45, 31, 34, 43, 40, 43, 55, 39, 45, 33, 51, 25, 62, 31, 25, 28, 34, 52, 24, 23, 36, 87, 32, 54, 42, 26, 52, 46, 58, 39, 63, 51, 22, 31, 35, 42, 42, 49, 36, 24, 63, 69, 27, 49, 50, 39, 22, 28, 40, 31, 34, 42, 36, 43, 51, 45, 20, 28, 63, 54, 19, 54, 49, 25, 49, 21, 47, 36, 42, 38, 33, 24, 19, 31, 35, 39, 49, 9, 44, 27, 16, 47, 33, 45, 50, 51, 37, 36, 32, 64, 41, 47, 53, 59, 29, 69, 28, 65, 42, 44, 31, 47, 37, 37, 25, 62, 39, 28, 51, 55, 62, 39, 39, 38, 54, 45, 18, 54, 44, 26, 34, 52, 32, 28, 58, 29, 38, 39, 55, 46, 26, 60, 23, 50, 34, 40, 58, 31, 46, 36, 31, 54, 46, 54, 27, 77, 62, 55, 36, 20, 53, 54, 37, 50, 59, 34, 37, 44, 33, 27, 62, 29, 31, 57, 44, 43, 46, 40, 22, 45, 33, 31, 39, 51, 51, 51, 48, 61, 61, 22, 48, 47, 49, 35, 33, 15, 10, 34, 33, 52, 81, 50, 59, 57, 41, 21, 45, 64, 56, 30, 39, 37, 47, 42, 46, 23, 59, 25, 23, 48, 58, 16, 39, 20, 46, 52, 23, 55, 43, 40, 36, 28, 44, 28, 21, 60, 39, 27, 55, 39, 38, 46, 27, 40, 60, 40, 38, 22, 48, 41, 24, 20, 49, 36, 27, 17, 67, 36, 66, 42, 48, 49, 89, 31, 38, 40, 10, 24, 63, 35, 67, 43, 54, 15, 31, 41, 60, 53, 31, 34, 15, 35, 33, 19, 38, 22, 32, 32, 33, 59, 54, 18, 40, 18, 37, 41, 30, 36, 49, 56, 43, 52, 33, 62, 25, 28, 36, 16, 50, 19, 47, 69, 16, 32, 41, 45, 45, 42, 61, 61, 29, 25, 40, 39, 49, 52, 45, 37, 51, 32, 32, 55, 82, 42, 17, 30, 53, 34, 60, 38, 44, 49, 31, 48, 40, 24, 35, 14, 37, 23, 56, 41, 28, 22, 17, 47, 28, 47, 39, 32, 49, 26, 53, 31, 24, 32, 45, 65, 25, 26, 43, 34, 51, 29, 27, 53, 77, 24, 48, 38, 39, 15, 75, 18, 56, 45, 71, 32, 41, 46, 19, 51, 50, 44, 59, 46, 41, 16, 23, 75, 55, 31, 35, 75, 44, 50, 57, 40, 59, 63, 29, 52, 32, 45, 25, 33, 39, 46, 63, 23, 37, 47, 23, 40, 38, 16, 23, 38, 23, 32, 38, 56, 26, 51, 30, 26, 15, 24, 49, 49, 34, 33, 44, 32, 10, 14, 30, 37, 34, 36, 74, 38, 29, 33, 23, 45, 34, 40, 25, 39, 18, 50, 71, 40, 27, 22, 35, 11, 24, 52, 38, 24, 51, 27, 36, 52, 16, 40, 44, 55, 29, 6, 43, 41, 32, 38, 53, 43, 36, 25, 54, 34, 50, 66, 46, 67, 19, 47, 34, 27, 38, 34, 44, 28, 31, 51, 34, 46, 38, 44, 61, 35, 53, 17, 25, 35, 48, 52, 34, 26, 17, 37, 37, 22, 19, 60, 48, 68, 75, 44, 26, 37, 55, 31, 31, 54, 51, 64, 67, 20, 62, 41, 45, 25, 35, 25, 15, 47, 48, 17, 36, 40, 43, 48, 36, 40, 28, 54, 52, 19, 40, 47, 26, 42, 48, 22, 51, 22, 46, 59, 51, 24, 50, 47, 17, 52, 23, 45, 19, 63, 30, 47, 46, 46, 22, 41, 62, 26, 14, 31, 48, 50, 68, 38, 33, 42, 44, 44, 19, 19, 11, 13, 33, 48, 54, 46, 48, 24, 16, 58, 21, 18, 38, 44, 26, 57, 41, 55, 53, 37, 35, 55, 52, 32, 40, 54, 41, 60, 46, 48, 34, 17, 45, 41, 37, 39, 22, 26, 16, 44, 49, 65, 15, 42, 37, 22, 26, 47, 37, 19, 48, 69, 43, 52, 43, 20, 46, 35, 25, 54, 26, 34, 43, 41, 44, 47, 8, 77, 30, 17, 46, 9, 58, 43, 41, 65, 50, 49, 38, 61, 44, 54, 22, 33, 31, 30, 19, 49, 56, 18, 68, 27, 47, 43, 13, 53, 41, 28, 54, 52, 27, 36, 29, 34, 46, 45, 39, 84, 29, 30, 28, 43, 55, 30, 13, 24, 41, 29, 30, 21, 21, 40, 60, 40, 33, 68, 25, 25, 53, 20, 56, 51, 26, 20, 47, 34, 64, 21, 33, 25, 62, 36, 48, 46, 43, 42, 66, 77, 29, 39, 34, 35, 16, 30, 10, 33, 57, 41, 36, 23, 50, 14, 32, 17, 31, 27, 62, 28, 35, 30, 60, 45, 22, 33, 26, 70, 49, 28, 35, 32, 39, 22, 59, 44, 19, 37, 28, 45, 13, 9, 41, 38, 21, 44, 12, 64, 44, 48, 43, 58, 26, 40, 26, 54, 27, 30, 31, 41, 37, 33, 31, 47, 48, 42, 20, 46, 23, 36, 59, 33, 38, 20, 65, 51, 33, 46, 33, 32, 39, 41, 31, 63, 67, 44, 57, 17, 76, 32, 41, 42, 41, 33, 16, 71, 33, 32, 37, 29, 59, 70, 38, 39, 61, 26, 49, 70, 61, 42, 60, 46, 21, 46, 32, 47, 37, 29, 41, 43, 50, 34, 35, 23, 35, 59, 40, 38, 45, 30, 50, 37, 54, 76, 24, 40, 50, 19, 67, 35, 55, 75, 49, 28, 12, 55, 45, 78, 43, 55, 56, 35, 41, 42, 27, 58, 25, 52, 45, 32, 29, 15, 43, 25, 8, 31, 32, 16, 32, 38, 44, 23, 21, 37, 48, 37, 40, 22, 14, 29, 55, 26, 19, 46, 26, 22, 30, 56, 23, 8, 48, 33, 23, 63, 71, 53, 52, 24, 56, 49, 20, 40, 53, 36, 61, 56, 15, 31, 44, 35, 60, 46, 50, 54, 36, 55, 22, 25, 40, 40, 49, 46, 53, 19, 51, 51, 27, 51, 53, 22, 25, 21, 25, 18, 42, 55, 43, 39, 27, 42, 6, 38, 42, 62, 10, 39, 15, 32, 25, 48, 24, 41, 39, 75, 41, 22, 52, 11, 29, 54, 42, 30, 16, 21, 22, 42, 21, 64, 16, 18, 57, 47, 42, 3, 36, 13, 29, 52, 34, 28, 39, 74, 43, 50, 43, 42, 68, 22, 49, 35, 51, 47, 29, 36, 35, 27, 53, 13, 84, 29, 18, 33, 54, 54, 67, 45, 53, 41, 54, 18, 49, 39, 36, 46, 17, 31, 23, 33, 50, 39, 33, 43, 19, 35, 29, 41, 72, 52, 53, 45, 64, 26, 26, 45, 38, 31, 21, 31, 16, 15, 38, 32, 55, 26, 20, 37, 50, 20, 23, 50, 58, 82, 38, 54, 14, 47, 13, 21, 61, 38, 38, 14, 42, 55, 42, 45, 51, 58, 33, 37, 44, 44, 37, 10, 49, 63, 60, 35, 27, 47, 71, 60, 25, 46, 51, 29, 49, 51, 36, 17, 32, 32, 49, 24, 22, 35, 28, 87, 29, 34, 30, 23, 38, 31, 28, 33, 30, 40, 11, 59, 37, 69, 37, 53, 29, 55, 43, 46, 40, 21, 69, 44, 19, 41, 48, 33, 30, 24, 51, 37, 22, 22, 32, 54, 35, 47, 39, 9, 61, 53, 26, 60, 34, 48, 55, 32, 21, 27, 36, 35, 33, 34, 15, 38, 38, 41, 54, 50, 45, 26, 26, 38, 36, 29, 43, 43, 65, 46, 18, 53, 32, 14, 46, 31, 43, 13, 34, 33, 43, 68, 55, 18, 30, 52, 14, 31, 24, 9, 56, 24, 64, 65, 61, 38, 46, 58, 50, 49, 40, 56, 62, 47, 58, 50, 21, 17, 52, 22, 46, 51, 32, 55, 54, 50, 43, 36, 66, 63, 17, 61, 43, 40, 19, 45, 44, 42, 11, 46, 35, 23, 30, 29, 54, 26, 44, 16, 43, 26, 60, 32, 21, 11, 28, 37, 41, 46, 29, 60, 36, 46, 38, 59, 49, 31, 13, 28, 44, 50, 36, 34, 46, 38, 45, 54, 54, 37, 38, 30, 26, 47, 56, 52, 35, 40, 32, 34, 37, 44, 58, 43, 46, 83, 44, 32, 24, 39, 47, 16, 49, 11, 37, 52, 20, 43, 25, 46, 14, 44, 21, 45, 62, 15, 36, 26, 29, 47, 58, 42, 38, 40, 39, 26, 25, 21, 44, 28, 55, 57, 43, 34, 49, 19, 50, 34, 21, 31, 50, 35, 34, 51, 41, 69, 66, 21, 44, 26, 22, 47, 66, 43, 43, 65, 28, 30, 30, 25, 12, 31, 55, 28, 39, 33, 41, 33, 46, 9, 40, 65, 41, 27, 47, 50, 12, 19, 50, 52, 33, 49, 38, 39, 42, 67, 55, 36, 47, 23, 54, 34, 32]}, 'test_2': {'capacity': 100, 'num_items': 5000, 'items': [20, 47, 39, 29, 7, 45, 45, 18, 39, 48, 15, 25, 33, 40, 52, 32, 33, 30, 11, 57, 15, 44, 22, 23, 83, 19, 34, 17, 14, 34, 50, 36, 52, 62, 48, 68, 40, 33, 27, 18, 25, 37, 39, 46, 35, 50, 60, 66, 52, 32, 31, 25, 62, 38, 54, 31, 58, 34, 20, 42, 57, 19, 21, 30, 21, 29, 20, 47, 43, 31, 34, 70, 19, 27, 17, 61, 53, 20, 69, 37, 32, 40, 49, 47, 26, 55, 52, 62, 41, 53, 17, 16, 42, 43, 49, 41, 41, 38, 25, 41, 42, 28, 14, 40, 50, 47, 16, 26, 38, 46, 35, 39, 77, 14, 55, 51, 43, 41, 23, 27, 60, 60, 38, 14, 31, 54, 23, 44, 44, 32, 32, 27, 24, 40, 51, 8, 46, 29, 10, 48, 65, 31, 55, 13, 23, 50, 28, 13, 38, 60, 27, 32, 22, 25, 45, 54, 38, 35, 23, 60, 77, 77, 24, 27, 28, 45, 17, 54, 45, 55, 42, 32, 42, 67, 55, 33, 57, 41, 35, 16, 35, 36, 45, 23, 24, 34, 35, 37, 48, 57, 57, 46, 47, 51, 59, 60, 42, 31, 63, 40, 31, 37, 11, 20, 49, 51, 33, 49, 53, 31, 51, 44, 39, 30, 41, 17, 43, 51, 33, 17, 39, 42, 38, 52, 55, 46, 55, 45, 58, 43, 59, 40, 42, 5, 45, 31, 28, 36, 52, 53, 48, 47, 9, 38, 45, 27, 34, 38, 47, 51, 34, 44, 40, 14, 67, 56, 30, 25, 42, 37, 21, 31, 69, 51, 46, 45, 55, 26, 58, 45, 50, 58, 44, 66, 27, 23, 28, 50, 39, 74, 30, 12, 24, 18, 27, 40, 55, 59, 58, 37, 29, 17, 17, 37, 21, 16, 41, 17, 39, 33, 42, 30, 60, 31, 32, 23, 32, 28, 17, 60, 24, 36, 29, 25, 81, 43, 44, 51, 51, 46, 28, 32, 36, 57, 39, 32, 31, 46, 35, 25, 70, 46, 50, 53, 50, 35, 49, 30, 33, 64, 41, 25, 29, 47, 26, 61, 54, 64, 29, 35, 35, 58, 47, 26, 58, 8, 66, 41, 64, 52, 22, 34, 38, 17, 14, 44, 33, 24, 36, 56, 49, 29, 35, 23, 15, 49, 79, 42, 36, 18, 50, 32, 27, 44, 36, 50, 51, 24, 83, 48, 35, 33, 37, 14, 32, 33, 34, 38, 40, 63, 31, 41, 51, 34, 71, 56, 37, 46, 52, 62, 36, 35, 57, 43, 26, 36, 43, 53, 17, 66, 39, 23, 42, 39, 17, 53, 57, 32, 44, 32, 44, 30, 53, 32, 41, 22, 38, 39, 15, 22, 45, 46, 59, 35, 31, 14, 37, 38, 24, 33, 53, 29, 39, 37, 61, 36, 47, 37, 29, 25, 47, 42, 31, 41, 59, 55, 28, 44, 49, 50, 33, 41, 51, 43, 32, 58, 55, 38, 49, 38, 36, 40, 54, 72, 53, 51, 42, 47, 49, 48, 57, 52, 33, 27, 33, 28, 41, 22, 48, 25, 50, 23, 41, 36, 54, 55, 25, 53, 26, 8, 47, 44, 48, 26, 8, 50, 39, 44, 68, 44, 70, 50, 44, 52, 39, 64, 41, 64, 52, 38, 16, 20, 11, 41, 25, 29, 35, 37, 17, 21, 46, 40, 32, 25, 14, 57, 29, 31, 20, 32, 48, 70, 48, 20, 61, 57, 25, 59, 35, 80, 27, 26, 54, 45, 54, 50, 46, 23, 48, 31, 40, 27, 43, 24, 48, 61, 36, 41, 41, 31, 42, 55, 49, 48, 37, 20, 35, 45, 37, 11, 32, 54, 50, 4, 24, 61, 48, 63, 38, 43, 38, 27, 20, 52, 22, 11, 38, 53, 27, 43, 26, 40, 47, 38, 42, 56, 52, 72, 53, 40, 25, 50, 43, 49, 32, 55, 25, 51, 37, 41, 56, 47, 37, 57, 29, 27, 60, 34, 42, 61, 46, 31, 38, 54, 48, 34, 55, 59, 38, 43, 22, 27, 28, 29, 30, 53, 60, 16, 55, 13, 39, 29, 28, 44, 42, 53, 60, 33, 48, 48, 44, 40, 57, 50, 59, 28, 31, 65, 23, 27, 44, 46, 57, 36, 60, 23, 23, 58, 51, 47, 15, 57, 50, 33, 14, 42, 44, 19, 24, 42, 40, 51, 37, 33, 50, 39, 38, 28, 31, 49, 55, 68, 42, 81, 21, 38, 55, 49, 39, 31, 36, 59, 62, 62, 79, 36, 55, 57, 23, 24, 32, 18, 53, 34, 70, 32, 38, 40, 43, 41, 35, 30, 53, 24, 47, 38, 36, 30, 52, 28, 67, 58, 23, 29, 33, 21, 54, 42, 44, 41, 33, 52, 35, 42, 39, 44, 50, 34, 53, 29, 50, 26, 8, 41, 39, 25, 48, 34, 45, 30, 35, 38, 57, 65, 34, 33, 47, 28, 42, 62, 42, 12, 31, 51, 13, 51, 47, 28, 76, 54, 34, 66, 18, 51, 32, 27, 48, 46, 15, 36, 43, 58, 35, 32, 41, 43, 16, 52, 22, 70, 19, 34, 25, 45, 27, 41, 33, 43, 47, 43, 62, 29, 62, 56, 33, 23, 72, 66, 44, 28, 29, 16, 20, 55, 53, 48, 59, 44, 44, 39, 14, 42, 40, 47, 67, 28, 51, 19, 44, 42, 41, 50, 12, 47, 37, 38, 11, 31, 51, 25, 29, 5, 22, 32, 51, 44, 56, 61, 43, 16, 50, 38, 20, 62, 70, 31, 37, 30, 69, 46, 13, 19, 45, 20, 10, 42, 34, 64, 56, 10, 35, 41, 32, 34, 48, 61, 55, 37, 49, 40, 26, 42, 35, 44, 41, 62, 29, 34, 34, 41, 54, 55, 35, 34, 37, 30, 29, 36, 62, 35, 38, 45, 31, 35, 37, 43, 38, 48, 45, 43, 28, 50, 49, 42, 64, 29, 75, 47, 60, 30, 55, 56, 62, 48, 35, 36, 22, 43, 56, 30, 37, 41, 21, 31, 60, 56, 15, 38, 32, 53, 25, 26, 36, 65, 40, 30, 42, 54, 47, 10, 11, 36, 61, 31, 53, 33, 21, 58, 42, 39, 43, 83, 44, 26, 25, 52, 10, 30, 29, 45, 30, 56, 39, 12, 38, 56, 33, 29, 31, 42, 36, 25, 24, 44, 54, 43, 48, 29, 38, 57, 50, 21, 67, 42, 28, 38, 22, 68, 11, 38, 15, 28, 58, 47, 24, 43, 50, 27, 17, 38, 20, 39, 53, 34, 61, 37, 57, 30, 20, 33, 65, 43, 44, 65, 38, 38, 15, 69, 49, 40, 30, 41, 14, 45, 43, 27, 56, 30, 45, 53, 39, 72, 32, 35, 15, 48, 18, 66, 54, 58, 44, 40, 40, 48, 25, 33, 62, 38, 43, 38, 20, 21, 29, 45, 35, 41, 61, 48, 25, 42, 36, 25, 34, 51, 39, 46, 53, 68, 21, 26, 18, 49, 49, 12, 29, 29, 46, 63, 38, 32, 49, 67, 28, 39, 19, 42, 55, 44, 44, 29, 26, 29, 33, 24, 22, 22, 57, 55, 29, 19, 34, 59, 43, 45, 37, 58, 80, 28, 76, 39, 51, 20, 32, 55, 34, 43, 65, 14, 60, 41, 33, 30, 35, 38, 51, 37, 49, 33, 43, 34, 21, 91, 9, 67, 41, 52, 24, 45, 35, 38, 35, 33, 37, 52, 42, 37, 45, 24, 44, 38, 32, 47, 38, 47, 65, 73, 31, 47, 46, 29, 70, 35, 36, 19, 34, 59, 46, 23, 31, 31, 21, 33, 32, 32, 43, 43, 23, 66, 52, 20, 35, 51, 47, 23, 58, 40, 44, 43, 12, 75, 41, 31, 35, 30, 48, 34, 28, 47, 43, 53, 37, 57, 36, 37, 45, 41, 60, 34, 33, 41, 17, 26, 67, 63, 46, 69, 29, 46, 27, 51, 38, 39, 47, 33, 31, 58, 38, 32, 53, 39, 41, 44, 20, 15, 23, 52, 44, 46, 49, 40, 13, 46, 25, 52, 48, 44, 29, 70, 42, 41, 19, 36, 54, 28, 48, 42, 34, 64, 13, 22, 46, 60, 58, 65, 52, 46, 38, 56, 36, 52, 18, 41, 64, 59, 41, 47, 20, 64, 15, 33, 72, 45, 36, 51, 47, 39, 38, 30, 58, 78, 56, 47, 38, 53, 36, 21, 62, 57, 37, 46, 54, 14, 36, 58, 67, 42, 41, 37, 31, 30, 55, 59, 46, 42, 31, 42, 22, 24, 62, 36, 52, 44, 54, 30, 24, 61, 19, 49, 63, 52, 57, 42, 9, 66, 17, 54, 23, 40, 27, 59, 53, 45, 48, 42, 22, 22, 42, 51, 47, 30, 40, 26, 34, 50, 47, 33, 37, 27, 31, 45, 61, 34, 40, 36, 29, 59, 34, 56, 38, 24, 32, 51, 47, 26, 22, 69, 25, 58, 25, 57, 11, 45, 15, 54, 34, 52, 16, 47, 29, 54, 18, 29, 32, 66, 43, 51, 37, 59, 46, 35, 19, 44, 43, 35, 18, 36, 59, 36, 33, 42, 42, 48, 35, 36, 5, 19, 35, 39, 63, 25, 44, 42, 41, 61, 52, 37, 42, 37, 48, 51, 65, 41, 30, 29, 25, 44, 48, 74, 19, 22, 40, 28, 45, 35, 44, 35, 46, 27, 41, 75, 42, 19, 27, 39, 50, 19, 49, 32, 38, 71, 50, 24, 45, 31, 33, 23, 45, 32, 30, 60, 33, 25, 25, 34, 14, 46, 37, 38, 30, 34, 31, 49, 62, 42, 33, 39, 49, 23, 65, 27, 29, 81, 59, 54, 43, 31, 56, 23, 59, 65, 44, 50, 59, 45, 32, 41, 29, 11, 14, 25, 37, 22, 37, 44, 62, 44, 28, 53, 9, 49, 44, 34, 49, 67, 51, 37, 26, 45, 28, 24, 57, 31, 54, 16, 36, 32, 22, 28, 19, 24, 39, 69, 46, 22, 39, 58, 45, 41, 23, 26, 60, 35, 50, 43, 35, 57, 32, 19, 45, 10, 42, 36, 15, 78, 40, 57, 21, 33, 56, 51, 15, 67, 26, 25, 64, 38, 36, 39, 43, 30, 35, 34, 44, 29, 29, 18, 32, 40, 68, 46, 24, 40, 48, 31, 40, 19, 36, 45, 57, 17, 18, 31, 31, 31, 25, 53, 42, 34, 21, 48, 30, 7, 56, 48, 25, 32, 52, 44, 32, 55, 57, 59, 63, 48, 33, 9, 12, 44, 42, 50, 44, 37, 56, 57, 26, 42, 27, 49, 31, 24, 14, 31, 51, 26, 15, 27, 37, 37, 57, 30, 53, 41, 12, 57, 42, 27, 31, 40, 18, 56, 22, 37, 48, 30, 35, 36, 37, 32, 35, 49, 35, 34, 38, 26, 57, 60, 46, 32, 50, 37, 41, 36, 45, 47, 40, 45, 29, 18, 40, 53, 52, 42, 33, 26, 44, 32, 39, 60, 43, 60, 24, 44, 75, 55, 27, 32, 19, 20, 42, 21, 41, 41, 47, 34, 46, 55, 38, 35, 49, 36, 45, 34, 22, 41, 68, 31, 12, 36, 27, 52, 46, 26, 15, 37, 59, 26, 52, 38, 35, 54, 13, 48, 46, 55, 57, 39, 52, 35, 44, 52, 24, 51, 41, 59, 53, 36, 38, 62, 44, 58, 18, 41, 44, 44, 26, 38, 35, 42, 49, 52, 37, 33, 46, 56, 42, 44, 47, 63, 24, 47, 69, 31, 32, 11, 23, 46, 43, 53, 65, 56, 17, 54, 29, 36, 38, 54, 33, 37, 53, 46, 30, 46, 28, 30, 41, 31, 23, 49, 35, 33, 62, 43, 44, 30, 18, 52, 57, 38, 42, 30, 42, 44, 44, 39, 46, 50, 44, 27, 61, 29, 31, 33, 41, 68, 49, 36, 13, 32, 62, 41, 59, 39, 24, 12, 57, 53, 31, 66, 19, 47, 47, 51, 60, 21, 41, 50, 49, 31, 26, 64, 26, 48, 29, 4, 35, 48, 51, 52, 33, 23, 26, 60, 44, 55, 23, 44, 41, 47, 52, 26, 13, 75, 12, 53, 43, 54, 40, 57, 36, 17, 33, 49, 25, 54, 10, 34, 43, 28, 37, 48, 31, 25, 54, 22, 70, 55, 39, 57, 39, 14, 39, 20, 57, 39, 35, 42, 40, 35, 30, 70, 24, 43, 42, 28, 43, 13, 32, 19, 42, 53, 63, 31, 44, 19, 41, 29, 51, 30, 61, 45, 43, 47, 65, 56, 53, 23, 27, 54, 39, 56, 47, 50, 54, 49, 51, 15, 35, 32, 68, 41, 76, 16, 43, 36, 23, 40, 43, 12, 30, 56, 57, 47, 18, 31, 53, 22, 47, 21, 39, 47, 43, 29, 51, 29, 39, 36, 54, 24, 30, 62, 36, 70, 16, 46, 24, 15, 26, 20, 42, 55, 29, 57, 59, 30, 47, 60, 37, 43, 43, 27, 42, 55, 26, 12, 16, 45, 42, 57, 39, 22, 37, 38, 41, 38, 46, 22, 10, 51, 32, 38, 41, 17, 17, 28, 35, 43, 25, 51, 35, 45, 67, 42, 18, 41, 35, 77, 30, 20, 46, 46, 43, 44, 41, 50, 29, 45, 26, 31, 41, 32, 44, 31, 58, 26, 30, 66, 14, 55, 30, 19, 48, 55, 53, 15, 64, 32, 43, 21, 40, 78, 37, 29, 46, 29, 25, 40, 67, 32, 53, 29, 48, 28, 48, 26, 70, 53, 52, 47, 19, 22, 44, 49, 48, 29, 55, 44, 30, 55, 32, 50, 51, 45, 63, 71, 28, 13, 26, 48, 34, 43, 49, 39, 38, 69, 14, 32, 38, 50, 48, 37, 50, 33, 52, 28, 39, 46, 37, 30, 28, 28, 32, 35, 24, 38, 33, 36, 52, 37, 27, 32, 15, 41, 36, 53, 23, 33, 11, 43, 48, 32, 50, 35, 69, 31, 39, 10, 22, 18, 40, 21, 8, 39, 39, 32, 28, 35, 61, 47, 28, 41, 61, 71, 39, 37, 42, 55, 46, 23, 42, 64, 28, 33, 22, 65, 26, 35, 26, 23, 22, 53, 51, 50, 22, 50, 49, 28, 15, 48, 58, 53, 51, 44, 25, 26, 59, 47, 51, 25, 21, 40, 32, 26, 35, 68, 34, 17, 59, 63, 29, 22, 27, 8, 21, 49, 43, 46, 28, 53, 43, 16, 58, 56, 56, 38, 41, 53, 51, 58, 50, 52, 31, 44, 26, 36, 52, 38, 14, 31, 40, 24, 52, 58, 37, 56, 43, 62, 58, 25, 55, 30, 40, 60, 26, 23, 26, 61, 18, 43, 43, 47, 21, 38, 51, 33, 60, 39, 40, 40, 58, 38, 43, 31, 49, 28, 20, 48, 36, 42, 28, 36, 22, 62, 19, 52, 28, 47, 51, 58, 56, 32, 29, 75, 55, 32, 40, 34, 47, 57, 49, 32, 41, 20, 25, 38, 42, 30, 53, 24, 25, 53, 42, 17, 29, 21, 44, 46, 33, 32, 54, 35, 48, 30, 66, 43, 44, 71, 66, 46, 57, 64, 9, 41, 22, 39, 45, 43, 33, 26, 46, 41, 34, 32, 66, 18, 40, 22, 52, 29, 73, 31, 36, 36, 50, 26, 56, 62, 19, 76, 43, 39, 55, 39, 44, 58, 15, 27, 16, 47, 35, 50, 23, 58, 57, 44, 53, 48, 24, 63, 20, 39, 40, 39, 30, 38, 32, 44, 29, 43, 30, 49, 45, 45, 42, 69, 16, 26, 57, 36, 37, 56, 47, 15, 57, 64, 36, 50, 42, 39, 9, 45, 14, 36, 33, 34, 47, 32, 52, 26, 41, 33, 19, 43, 15, 25, 55, 59, 33, 33, 32, 44, 56, 67, 84, 33, 42, 44, 61, 47, 24, 71, 29, 22, 36, 33, 41, 19, 36, 24, 51, 36, 29, 26, 26, 35, 28, 38, 49, 58, 35, 47, 31, 43, 30, 23, 19, 29, 33, 50, 44, 71, 13, 20, 22, 31, 44, 62, 23, 25, 31, 24, 48, 25, 58, 32, 31, 37, 34, 63, 56, 16, 59, 51, 25, 30, 69, 32, 39, 50, 55, 28, 37, 87, 35, 70, 52, 33, 41, 47, 9, 52, 55, 32, 59, 47, 79, 35, 55, 12, 25, 24, 36, 18, 52, 34, 28, 56, 20, 35, 24, 40, 61, 42, 61, 29, 29, 30, 64, 45, 22, 45, 28, 45, 30, 46, 47, 33, 25, 34, 43, 53, 41, 20, 43, 60, 49, 46, 55, 50, 32, 45, 33, 62, 14, 57, 54, 35, 26, 58, 36, 52, 68, 29, 56, 30, 13, 38, 22, 30, 33, 52, 35, 63, 42, 50, 44, 23, 52, 37, 17, 56, 49, 44, 50, 50, 48, 37, 52, 35, 43, 46, 12, 52, 45, 34, 36, 22, 46, 51, 50, 33, 34, 35, 25, 28, 71, 33, 34, 10, 19, 20, 42, 39, 73, 37, 39, 30, 43, 40, 15, 55, 35, 32, 49, 51, 41, 55, 42, 44, 46, 20, 44, 61, 46, 55, 34, 27, 32, 33, 41, 56, 33, 63, 7, 34, 7, 36, 36, 50, 15, 30, 45, 29, 39, 62, 30, 66, 37, 40, 61, 35, 25, 64, 20, 38, 29, 17, 23, 41, 42, 50, 49, 45, 27, 28, 46, 69, 24, 57, 34, 43, 22, 34, 19, 30, 21, 11, 62, 47, 44, 50, 37, 39, 32, 33, 10, 56, 39, 17, 35, 57, 42, 55, 41, 30, 38, 27, 44, 28, 31, 36, 52, 17, 12, 37, 47, 48, 20, 55, 47, 38, 62, 48, 41, 48, 46, 22, 59, 37, 39, 30, 39, 32, 19, 51, 33, 61, 52, 46, 47, 34, 32, 44, 41, 42, 64, 23, 31, 48, 62, 19, 50, 34, 40, 21, 43, 19, 31, 57, 37, 52, 69, 49, 45, 28, 35, 23, 21, 35, 27, 41, 58, 8, 20, 41, 37, 46, 26, 45, 21, 39, 54, 21, 41, 41, 26, 58, 16, 69, 49, 26, 30, 32, 63, 51, 30, 74, 42, 36, 46, 31, 54, 24, 27, 21, 62, 30, 41, 34, 62, 59, 21, 40, 22, 29, 69, 31, 17, 36, 44, 36, 65, 49, 52, 52, 22, 51, 35, 55, 28, 43, 28, 45, 28, 48, 49, 47, 41, 34, 60, 28, 45, 32, 77, 44, 36, 25, 58, 17, 50, 51, 39, 40, 9, 52, 21, 15, 41, 34, 49, 57, 28, 21, 47, 26, 68, 47, 13, 54, 49, 26, 63, 34, 52, 35, 28, 7, 46, 63, 17, 20, 32, 27, 42, 17, 55, 50, 14, 33, 45, 36, 15, 10, 46, 25, 41, 49, 67, 20, 27, 49, 28, 36, 68, 37, 34, 59, 44, 55, 34, 69, 51, 56, 36, 30, 63, 60, 84, 48, 44, 44, 47, 34, 58, 45, 39, 23, 33, 39, 85, 64, 56, 42, 46, 43, 35, 32, 55, 28, 46, 23, 58, 28, 31, 54, 52, 31, 48, 35, 50, 24, 35, 54, 13, 10, 23, 51, 38, 24, 53, 3, 18, 34, 55, 54, 23, 42, 54, 12, 36, 50, 39, 43, 29, 38, 36, 41, 40, 36, 32, 29, 46, 37, 69, 36, 36, 50, 40, 28, 21, 45, 42, 16, 49, 50, 36, 37, 24, 30, 32, 29, 36, 20, 57, 16, 25, 53, 49, 23, 51, 40, 22, 59, 32, 45, 40, 31, 44, 39, 26, 29, 38, 60, 41, 71, 39, 37, 20, 26, 39, 32, 40, 45, 43, 67, 32, 45, 53, 29, 54, 36, 41, 33, 24, 57, 51, 55, 40, 64, 25, 27, 20, 18, 31, 43, 18, 24, 30, 25, 48, 53, 18, 39, 37, 54, 25, 35, 31, 35, 34, 30, 44, 12, 45, 31, 44, 38, 17, 50, 31, 31, 37, 42, 43, 33, 35, 22, 26, 48, 47, 33, 58, 29, 53, 31, 27, 66, 6, 60, 46, 36, 27, 66, 54, 57, 71, 5, 12, 42, 42, 15, 28, 43, 71, 21, 53, 48, 33, 27, 55, 14, 51, 34, 17, 53, 30, 32, 37, 59, 39, 29, 64, 50, 48, 51, 32, 28, 29, 32, 49, 18, 58, 49, 46, 35, 50, 40, 48, 33, 27, 35, 51, 38, 51, 57, 14, 78, 34, 18, 33, 33, 35, 45, 34, 40, 12, 25, 53, 56, 27, 31, 40, 27, 48, 68, 48, 29, 42, 19, 38, 53, 33, 19, 54, 17, 27, 42, 69, 60, 37, 65, 57, 55, 65, 48, 42, 76, 23, 26, 64, 52, 55, 6, 27, 26, 29, 30, 26, 64, 50, 59, 54, 58, 34, 47, 42, 50, 55, 53, 24, 28, 21, 51, 39, 56, 37, 49, 37, 56, 37, 58, 49, 39, 61, 40, 41, 19, 50, 65, 50, 53, 45, 54, 20, 30, 29, 27, 53, 37, 56, 24, 37, 54, 46, 18, 11, 43, 19, 34, 22, 27, 29, 35, 48, 56, 48, 53, 27, 38, 39, 26, 33, 15, 62, 28, 56, 43, 31, 15, 45, 50, 23, 49, 27, 57, 25, 36, 32, 54, 60, 38, 33, 28, 32, 49, 34, 14, 27, 58, 20, 21, 23, 43, 38, 29, 52, 78, 41, 63, 50, 38, 36, 39, 65, 36, 38, 61, 59, 47, 45, 17, 57, 24, 69, 74, 23, 50, 32, 35, 55, 42, 54, 47, 29, 52, 42, 27, 12, 60, 11, 33, 28, 48, 38, 25, 45, 59, 28, 61, 42, 33, 29, 27, 64, 20, 27, 15, 56, 15, 64, 34, 41, 27, 77, 52, 51, 36, 40, 43, 59, 23, 19, 49, 44, 47, 45, 37, 38, 39, 31, 35, 41, 18, 55, 38, 60, 38, 20, 52, 21, 26, 49, 73, 35, 29, 32, 29, 17, 47, 31, 38, 36, 31, 33, 22, 14, 17, 44, 72, 54, 58, 32, 49, 29, 28, 50, 62, 42, 35, 30, 22, 35, 29, 40, 43, 42, 50, 33, 42, 61, 42, 40, 34, 44, 30, 15, 64, 48, 35, 25, 44, 41, 53, 26, 46, 61, 38, 20, 39, 63, 24, 34, 52, 17, 30, 41, 45, 40, 55, 56, 27, 44, 31, 23, 24, 52, 39, 24, 51, 46, 60, 27, 52, 34, 62, 22, 48, 58, 38, 39, 60, 72, 24, 51, 51, 12, 48, 7, 20, 19, 46, 27, 45, 21, 31, 34, 35, 50, 6, 40, 45, 47, 42, 37, 24, 66, 43, 39, 40, 64, 30, 48, 9, 47, 47, 59, 40, 34, 46, 33, 45, 44, 49, 34, 56, 48, 31, 39, 58, 62, 30, 24, 42, 28, 59, 57, 61, 38, 60, 35, 23, 46, 46, 40, 44, 43, 38, 34, 51, 49, 49, 39, 37, 21, 74, 48, 80, 39, 30, 23, 53, 48, 42, 20, 44, 35, 53, 34, 52, 14, 32, 73, 36, 24, 41, 42, 46, 39, 35, 40, 18, 14, 34, 27, 38, 54, 28, 29, 41, 71, 18, 48, 41, 32, 34, 13, 37, 24, 23, 38, 47, 42, 47, 53, 38, 31, 9, 37, 59, 33, 29, 67, 9, 27, 44, 53, 13, 29, 38, 52, 32, 31, 22, 54, 43, 42, 20, 32, 43, 17, 60, 17, 38, 40, 25, 67, 50, 40, 16, 72, 41, 43, 12, 47, 10, 34, 31, 28, 43, 63, 55, 42, 17, 31, 62, 53, 19, 22, 28, 46, 42, 29, 76, 17, 21, 41, 31, 32, 42, 43, 43, 24, 36, 59, 5, 60, 37, 18, 46, 9, 48, 53, 51, 60, 40, 21, 9, 19, 38, 44, 32, 41, 30, 43, 52, 26, 20, 46, 37, 40, 54, 40, 36, 10, 29, 54, 56, 19, 35, 59, 33, 42, 39, 32, 50, 31, 33, 57, 15, 32, 34, 41, 55, 43, 55, 59, 41, 69, 32, 34, 21, 34, 32, 43, 55, 27, 28, 49, 22, 34, 37, 36, 39, 58, 42, 45, 50, 14, 39, 56, 46, 73, 21, 29, 37, 34, 56, 55, 37, 44, 49, 40, 51, 64, 64, 62, 60, 10, 43, 34, 43, 20, 31, 44, 41, 40, 29, 57, 68, 47, 44, 28, 27, 34, 53, 49, 48, 38, 51, 25, 15, 31, 28, 42, 50, 37, 33, 38, 24, 36, 29, 38, 65, 48, 60, 40, 40, 42, 10, 36, 36, 46, 64, 45, 38, 51, 20, 45, 39, 38, 44, 12, 61, 27, 44, 62, 50, 69, 57, 58, 53, 31, 56, 29, 39, 21, 35, 40, 29, 36, 28, 56, 15, 55, 59, 50, 46, 8, 38, 54, 15, 46, 29, 59, 56, 52, 33, 34, 74, 34, 38, 43, 25, 37, 42, 40, 64, 58, 31, 28, 47, 21, 60, 54, 62, 70, 27, 44, 17, 25, 35, 7, 58, 6, 68, 39, 37, 4, 44, 30, 41, 12, 42, 24, 31, 24, 58, 48, 37, 38, 44, 43, 45, 42, 31, 17, 41, 52, 55, 45, 24, 5, 56, 73, 25, 30, 36, 59, 24, 46, 18, 57, 30, 31, 34, 40, 61, 46, 49, 40, 44, 45, 20, 43, 33, 42, 38, 54, 10, 39, 42, 40, 12, 48, 36, 32, 33, 43, 38, 28, 28, 18, 61, 27, 23, 37, 51, 31, 30, 46, 22, 32, 27, 36, 44, 79, 45, 50, 44, 6, 33, 28, 31, 15, 36, 54, 43, 51, 51, 21, 57, 21, 24, 17, 53, 38, 41, 37, 18, 21, 27, 43, 42, 20, 18, 55, 21, 36, 43, 26, 38, 46, 44, 50, 27, 19, 45, 45, 39, 25, 56, 27, 45, 55, 36, 37, 30, 30, 27, 38, 44, 52, 30, 48, 42, 29, 27, 24, 14, 38, 18, 38, 52, 36, 17, 37, 53, 59, 61, 12, 27, 36, 24, 16, 22, 31, 55, 45, 54, 45, 51, 29, 32, 33, 46, 30, 49, 51, 47, 71, 52, 33, 12, 36, 39, 33, 53, 43, 32, 76, 39, 25, 31, 28, 14, 40, 70, 35, 30, 51, 44, 47, 39, 48, 43, 33, 37, 12, 34, 62, 46, 36, 44, 25, 69, 36, 24, 13, 34, 45, 28, 47, 27, 58, 14, 36, 45, 36, 35, 20, 55, 14, 29, 50, 50, 33, 28, 24, 38, 26, 68, 55, 20, 33, 47, 56, 67, 48, 39, 37, 50, 51, 29, 20, 34, 33, 53, 45, 28, 51, 50, 39, 53, 50, 58, 46, 43, 16, 31, 50, 71, 40, 41, 66, 40, 33, 38, 48, 52, 11, 28, 29, 49, 56, 23, 46, 51, 58, 49, 33, 47, 28, 41, 51, 25, 45, 41, 28, 39, 54, 41, 28, 26, 35, 33, 56, 45, 39, 27, 40, 48, 25, 40, 51, 51, 33, 32, 41, 10, 41, 55, 43, 26, 28, 50, 46, 29, 35, 19, 27, 28, 55, 36, 57, 64, 44, 34, 34, 32, 26, 30, 36, 20, 40, 6, 37, 33, 49, 68, 45, 34, 54, 52, 48, 65, 37, 35, 32, 48, 41, 48, 32, 43, 26, 41, 35, 41, 62, 35, 26, 45, 31, 30, 37, 23, 68, 40, 16, 28, 28, 24, 39, 46, 12, 40, 45, 44, 35, 53, 38, 42, 27, 32, 39, 53, 18, 30, 45, 58, 42, 36, 67, 24, 36, 38, 9, 56, 61, 47, 60, 58, 66, 14, 35, 32, 32, 58, 38, 40, 37, 38, 44, 57, 34, 75, 44, 33, 29, 53, 44, 32, 40, 35, 55, 13, 35, 52, 31, 47, 16, 35, 56, 39, 33, 46, 47, 24, 46, 21, 35, 35, 17, 31, 39, 39, 36, 17, 29, 42, 33, 29, 54, 56, 24, 28, 48, 15, 44, 35, 35, 39, 60, 42, 48, 43, 58, 36, 46, 30, 45, 40, 63, 42, 15, 54, 34, 30, 54, 34, 21, 19, 25, 21, 19, 47, 28, 58, 28, 11, 29, 36, 30, 56, 31, 38, 29, 48, 36, 34, 45, 35, 39, 55, 10, 31, 72, 44, 31, 44, 34, 15, 39, 5, 35, 35, 50, 66, 45, 50, 47, 40, 20, 22, 50, 34, 46, 55, 44, 55, 62, 38, 46, 45, 52, 27, 51, 33, 29, 16, 40, 37, 62, 37, 46, 26, 37, 47, 26, 39, 36, 35, 31, 48, 19, 41, 56, 44, 54, 67, 36, 27, 39, 31, 46, 19, 50, 29, 48, 28, 52, 49, 30, 39, 53, 54, 20, 29, 48, 40, 44, 49, 53, 19, 23, 33, 32, 47, 36, 42, 38, 24, 13, 52, 45, 52, 46, 59, 18, 31, 37, 35, 22, 26, 9, 12, 20, 36, 10, 41, 31, 48, 42, 44, 29, 38, 53, 27, 50, 46, 64, 22, 30, 37, 24, 50, 52, 32, 43, 51, 78, 70, 62, 34, 58, 27, 61, 27, 54, 59, 48, 42, 58, 67, 50, 24, 42, 30, 29, 36, 52, 53, 27, 20, 38, 9, 29, 17, 34, 26, 8, 32, 52, 27, 31, 35, 31, 23, 50, 24, 41, 67, 44, 69, 21, 30, 58, 33, 32, 44, 53, 41, 41, 40, 15, 48, 56, 39, 37, 59, 20, 61, 38, 44, 23, 28, 32, 54, 29, 33, 46, 42, 63, 58, 47, 37, 32, 12, 39, 46, 13, 56, 68, 49, 59, 35, 23, 13, 47, 27, 69, 4, 49, 35, 60, 41, 5, 28, 67, 51, 42, 45, 28, 36, 42, 52, 50, 46, 36, 35, 17, 33, 20, 23, 53, 38, 39, 43, 29, 37, 55, 44, 32, 35, 20, 63, 51, 39, 50, 30, 27, 80, 18, 53, 54, 51, 53, 39, 32, 63, 10, 31, 32, 39, 38, 44, 30, 37, 40, 44, 43, 30, 20, 44, 58, 70, 65, 54, 47, 40, 54, 36, 46, 48, 54, 31, 29, 47, 48, 27, 46, 24, 40, 50, 28, 50, 31, 19, 50, 61, 37, 36, 47, 25, 67, 31, 38, 19, 39, 25, 14, 76, 34, 52, 22, 55, 47, 20, 39, 34, 54, 40, 44, 59, 48, 41, 50, 29, 25, 42, 64, 38, 23, 55, 27, 40, 47, 24, 34, 66, 31, 56, 10, 46, 43, 45, 30, 48, 15, 28, 43, 50, 16, 35, 28, 45, 40, 38, 48, 16, 26, 30, 26, 30, 68, 67, 53, 44, 45, 51, 47, 45, 29, 45, 46, 46, 75, 21, 28, 30, 35, 44, 45, 42, 48, 33, 52, 49, 53, 39, 36, 25, 49, 45, 17, 20, 61, 18, 29, 68, 50, 47, 28, 41, 26, 36, 40, 16, 46, 26, 38, 37, 59, 56, 18, 57, 33, 65, 44, 42, 37, 55, 38, 46, 8, 16, 51, 27, 51, 54, 27, 12, 10, 48, 70, 19, 39, 39, 28, 36, 23, 33, 32, 31, 24, 7, 37, 21, 31, 36, 46, 21, 51, 61, 54, 24, 36, 74, 40, 49, 25, 40, 46, 19, 28, 44, 58, 10, 34, 43, 45, 30, 36, 48, 33, 50, 43, 50, 35, 16, 40, 36, 38, 35, 54, 37, 40, 42, 14, 35, 41, 47, 51, 50, 61, 36, 58, 30, 46, 44, 38, 20, 11, 34, 42, 59, 38, 71, 40, 25, 35, 52, 26, 66, 49, 36, 31, 24, 52, 58, 60, 7, 31, 49, 35, 61, 56, 46, 32, 19, 78, 35]}, 'test_3': {'capacity': 100, 'num_items': 5000, 'items': [55, 51, 16, 43, 30, 49, 52, 44, 48, 29, 52, 34, 37, 25, 53, 48, 33, 34, 37, 72, 42, 46, 13, 64, 42, 66, 60, 37, 27, 48, 32, 46, 41, 36, 52, 22, 17, 30, 32, 37, 39, 35, 43, 55, 49, 23, 43, 66, 36, 42, 30, 37, 29, 44, 29, 48, 51, 47, 60, 51, 40, 36, 55, 60, 42, 60, 54, 20, 28, 43, 46, 41, 39, 36, 22, 23, 22, 44, 44, 41, 35, 50, 17, 30, 24, 46, 32, 66, 39, 54, 34, 24, 41, 49, 37, 41, 5, 34, 49, 44, 24, 44, 20, 31, 46, 32, 86, 31, 48, 38, 49, 16, 46, 58, 18, 41, 26, 61, 48, 51, 16, 48, 30, 48, 21, 34, 13, 37, 59, 30, 34, 68, 59, 36, 28, 19, 61, 50, 14, 44, 43, 18, 48, 69, 55, 63, 69, 69, 25, 55, 44, 55, 29, 63, 50, 47, 37, 40, 35, 25, 25, 34, 49, 30, 40, 34, 47, 43, 65, 69, 47, 67, 36, 56, 18, 16, 34, 48, 31, 13, 61, 42, 24, 52, 42, 35, 37, 33, 17, 21, 49, 57, 47, 27, 25, 52, 20, 20, 36, 40, 46, 44, 59, 46, 47, 54, 38, 65, 68, 54, 47, 36, 61, 25, 53, 34, 21, 54, 61, 27, 31, 50, 42, 43, 25, 29, 32, 26, 26, 37, 33, 29, 30, 64, 37, 52, 43, 43, 47, 59, 37, 38, 33, 66, 34, 32, 53, 14, 67, 10, 35, 58, 50, 23, 36, 46, 52, 34, 48, 24, 28, 47, 49, 19, 60, 20, 23, 18, 34, 32, 62, 31, 50, 53, 26, 53, 27, 39, 40, 61, 48, 41, 40, 32, 33, 42, 30, 31, 50, 19, 36, 64, 46, 36, 29, 55, 49, 43, 42, 62, 47, 36, 49, 47, 27, 59, 24, 46, 40, 48, 35, 39, 62, 31, 67, 37, 15, 10, 17, 66, 48, 35, 24, 36, 41, 17, 34, 43, 70, 44, 55, 50, 35, 42, 14, 33, 63, 12, 62, 56, 60, 17, 26, 45, 62, 68, 24, 66, 24, 52, 27, 12, 68, 43, 41, 38, 75, 65, 51, 63, 20, 24, 32, 46, 41, 32, 51, 64, 60, 11, 59, 54, 47, 60, 26, 38, 76, 15, 46, 7, 25, 57, 23, 32, 34, 26, 25, 38, 59, 45, 38, 33, 31, 37, 37, 44, 46, 21, 22, 52, 29, 19, 39, 41, 39, 31, 51, 32, 23, 21, 30, 49, 64, 28, 49, 19, 48, 19, 49, 16, 34, 46, 61, 13, 45, 39, 36, 36, 32, 40, 29, 54, 34, 37, 38, 65, 27, 28, 38, 46, 34, 38, 50, 54, 34, 39, 39, 21, 38, 44, 21, 52, 59, 33, 69, 38, 54, 13, 44, 52, 32, 28, 44, 43, 58, 21, 52, 35, 42, 34, 49, 39, 26, 69, 25, 37, 49, 54, 56, 65, 43, 32, 36, 27, 40, 23, 48, 24, 13, 25, 38, 29, 40, 26, 36, 50, 47, 25, 59, 24, 45, 28, 41, 23, 55, 44, 49, 64, 14, 49, 13, 12, 14, 61, 37, 63, 45, 17, 33, 27, 32, 15, 48, 54, 28, 36, 24, 45, 43, 26, 55, 29, 60, 53, 30, 87, 48, 51, 47, 54, 38, 53, 51, 25, 48, 12, 30, 36, 80, 63, 30, 33, 38, 33, 32, 24, 12, 29, 41, 26, 64, 37, 24, 83, 27, 62, 52, 45, 23, 39, 37, 51, 52, 48, 23, 34, 51, 27, 41, 50, 52, 73, 23, 38, 38, 25, 36, 52, 79, 21, 42, 60, 68, 48, 23, 15, 33, 39, 50, 23, 39, 64, 51, 16, 27, 41, 70, 50, 34, 29, 44, 18, 63, 47, 14, 36, 45, 69, 71, 42, 11, 49, 10, 43, 31, 48, 54, 31, 40, 35, 40, 38, 33, 46, 43, 34, 26, 49, 8, 46, 11, 27, 27, 11, 64, 47, 37, 41, 68, 28, 31, 69, 36, 40, 45, 49, 55, 35, 46, 44, 66, 50, 53, 37, 30, 66, 14, 63, 39, 45, 42, 37, 48, 55, 54, 32, 18, 64, 39, 49, 68, 35, 40, 16, 51, 51, 41, 54, 41, 27, 17, 40, 36, 54, 58, 36, 46, 29, 34, 35, 18, 41, 59, 49, 44, 36, 50, 29, 36, 15, 58, 30, 15, 46, 26, 30, 62, 50, 35, 19, 35, 20, 32, 19, 69, 19, 40, 51, 51, 53, 17, 38, 40, 10, 43, 22, 72, 33, 70, 14, 48, 38, 50, 42, 21, 28, 36, 44, 67, 34, 22, 17, 18, 28, 49, 66, 26, 53, 41, 21, 8, 26, 39, 54, 45, 42, 28, 49, 62, 66, 41, 36, 41, 32, 31, 20, 42, 26, 39, 37, 29, 29, 21, 41, 26, 36, 57, 44, 45, 26, 42, 44, 45, 47, 61, 51, 27, 22, 44, 44, 25, 7, 36, 21, 53, 26, 38, 26, 28, 60, 57, 28, 65, 64, 33, 34, 29, 26, 48, 42, 46, 21, 31, 62, 58, 47, 56, 42, 50, 52, 41, 23, 28, 64, 11, 46, 36, 56, 44, 58, 58, 29, 13, 68, 46, 45, 15, 29, 53, 51, 58, 27, 35, 47, 39, 48, 34, 26, 36, 54, 60, 56, 67, 40, 39, 63, 47, 44, 24, 58, 48, 48, 49, 46, 41, 68, 42, 50, 73, 23, 23, 36, 41, 43, 20, 63, 36, 20, 39, 49, 25, 32, 53, 21, 31, 54, 30, 22, 28, 37, 57, 37, 41, 42, 21, 14, 48, 22, 49, 39, 21, 36, 19, 31, 64, 50, 12, 32, 58, 45, 35, 21, 49, 58, 69, 48, 37, 27, 44, 32, 20, 24, 35, 49, 54, 19, 53, 40, 49, 67, 26, 49, 70, 43, 30, 38, 27, 35, 57, 39, 45, 38, 41, 15, 21, 54, 26, 34, 46, 64, 36, 28, 45, 63, 57, 67, 22, 26, 8, 42, 47, 36, 66, 23, 42, 24, 16, 37, 39, 57, 54, 26, 33, 17, 21, 66, 26, 32, 35, 54, 40, 19, 59, 41, 45, 34, 45, 31, 32, 20, 35, 50, 24, 41, 93, 47, 30, 45, 32, 45, 37, 40, 67, 32, 14, 28, 41, 62, 34, 28, 33, 28, 41, 61, 37, 46, 23, 32, 33, 39, 37, 49, 36, 32, 61, 27, 68, 62, 52, 40, 39, 46, 23, 49, 17, 38, 31, 23, 17, 25, 70, 47, 46, 50, 15, 34, 56, 51, 48, 74, 27, 64, 11, 51, 46, 37, 35, 51, 23, 35, 36, 31, 55, 32, 33, 49, 12, 39, 48, 20, 35, 58, 70, 36, 52, 21, 46, 32, 41, 42, 42, 13, 14, 44, 31, 51, 47, 21, 45, 43, 38, 44, 44, 32, 54, 30, 51, 36, 8, 44, 14, 28, 35, 34, 40, 28, 16, 49, 21, 33, 39, 48, 65, 38, 58, 38, 35, 41, 36, 77, 33, 38, 29, 23, 20, 59, 38, 30, 32, 25, 27, 28, 45, 43, 42, 23, 20, 37, 29, 49, 51, 10, 73, 12, 33, 30, 21, 48, 38, 48, 46, 31, 37, 35, 26, 67, 21, 66, 55, 43, 26, 49, 52, 39, 33, 59, 33, 25, 54, 55, 16, 19, 34, 49, 42, 44, 26, 32, 40, 25, 53, 33, 36, 61, 66, 55, 78, 54, 31, 44, 40, 25, 31, 65, 57, 50, 25, 17, 52, 23, 50, 24, 54, 28, 56, 26, 41, 46, 43, 43, 46, 39, 26, 26, 40, 59, 31, 24, 30, 14, 53, 34, 54, 34, 46, 66, 51, 52, 56, 30, 45, 38, 22, 49, 55, 40, 24, 54, 41, 44, 38, 39, 40, 15, 7, 76, 42, 53, 44, 39, 39, 41, 38, 53, 23, 52, 44, 28, 62, 41, 69, 43, 60, 37, 33, 37, 69, 38, 49, 35, 37, 29, 22, 37, 52, 40, 40, 20, 18, 30, 39, 49, 10, 9, 62, 47, 46, 27, 79, 43, 37, 34, 57, 56, 45, 42, 44, 47, 21, 27, 59, 36, 17, 39, 45, 69, 28, 28, 48, 20, 47, 48, 60, 31, 56, 43, 54, 19, 19, 59, 67, 23, 48, 52, 26, 50, 18, 70, 22, 15, 42, 39, 29, 64, 23, 57, 24, 31, 12, 25, 20, 54, 49, 65, 60, 41, 32, 45, 41, 57, 54, 35, 16, 27, 54, 55, 71, 33, 21, 51, 39, 45, 29, 36, 28, 7, 8, 34, 38, 26, 33, 81, 62, 15, 31, 19, 42, 25, 47, 53, 45, 49, 52, 33, 42, 34, 59, 54, 45, 54, 31, 47, 52, 42, 26, 46, 36, 41, 54, 31, 52, 60, 42, 41, 47, 43, 19, 54, 17, 31, 34, 77, 49, 12, 27, 36, 61, 31, 47, 45, 53, 48, 44, 18, 45, 51, 21, 32, 20, 38, 32, 15, 35, 45, 34, 38, 35, 48, 60, 61, 37, 54, 26, 74, 56, 22, 38, 20, 24, 42, 26, 48, 58, 61, 45, 40, 48, 50, 25, 36, 67, 44, 52, 30, 69, 35, 39, 46, 65, 76, 41, 45, 28, 34, 41, 27, 61, 51, 18, 34, 45, 20, 29, 54, 27, 32, 65, 16, 27, 47, 25, 17, 38, 38, 35, 34, 22, 34, 36, 15, 49, 47, 78, 20, 28, 26, 42, 34, 32, 38, 42, 50, 32, 47, 37, 32, 52, 39, 30, 29, 58, 27, 25, 38, 50, 49, 39, 50, 43, 27, 55, 49, 49, 58, 31, 18, 41, 49, 49, 31, 12, 41, 68, 51, 83, 22, 38, 39, 65, 35, 17, 49, 28, 21, 19, 53, 40, 44, 67, 49, 17, 25, 31, 24, 29, 41, 26, 35, 38, 36, 61, 38, 37, 13, 49, 58, 37, 32, 57, 46, 39, 38, 25, 47, 17, 50, 33, 51, 44, 47, 47, 35, 42, 47, 50, 31, 46, 11, 28, 52, 22, 31, 50, 54, 22, 39, 36, 29, 34, 34, 60, 47, 29, 40, 49, 26, 51, 26, 52, 39, 49, 14, 52, 19, 34, 48, 39, 14, 57, 40, 49, 16, 68, 45, 30, 29, 55, 40, 42, 43, 33, 61, 38, 40, 23, 9, 47, 59, 38, 38, 39, 30, 59, 45, 81, 48, 62, 22, 40, 20, 46, 19, 62, 56, 40, 34, 35, 34, 26, 40, 34, 26, 48, 37, 22, 45, 26, 38, 13, 21, 37, 37, 31, 56, 47, 17, 42, 12, 35, 58, 29, 40, 39, 34, 25, 50, 49, 10, 58, 62, 28, 84, 47, 41, 48, 62, 54, 49, 53, 58, 33, 52, 43, 27, 29, 53, 81, 52, 31, 23, 37, 50, 68, 28, 30, 14, 39, 55, 44, 40, 37, 28, 31, 42, 40, 51, 45, 58, 67, 36, 39, 34, 26, 61, 49, 57, 51, 42, 26, 63, 46, 41, 58, 13, 49, 39, 43, 49, 23, 43, 51, 51, 20, 47, 15, 55, 72, 18, 21, 25, 37, 49, 39, 45, 52, 39, 73, 31, 38, 36, 36, 29, 33, 33, 21, 22, 36, 41, 65, 69, 28, 28, 26, 59, 26, 41, 35, 14, 22, 44, 43, 40, 34, 54, 29, 36, 50, 37, 44, 48, 26, 44, 64, 32, 48, 46, 50, 37, 45, 40, 11, 31, 14, 32, 42, 40, 36, 34, 36, 48, 29, 16, 48, 55, 54, 58, 32, 35, 55, 28, 43, 24, 38, 52, 34, 34, 20, 63, 31, 57, 38, 31, 27, 51, 34, 18, 60, 47, 55, 39, 41, 39, 27, 39, 67, 57, 41, 21, 13, 39, 42, 28, 33, 32, 31, 57, 18, 50, 32, 16, 42, 44, 15, 31, 51, 48, 15, 22, 40, 29, 26, 14, 51, 38, 39, 40, 21, 52, 59, 23, 38, 26, 45, 32, 61, 40, 51, 35, 44, 53, 38, 49, 29, 26, 21, 37, 20, 54, 29, 56, 28, 75, 29, 47, 59, 36, 24, 31, 32, 51, 43, 45, 72, 44, 30, 62, 39, 30, 36, 37, 33, 31, 32, 39, 30, 64, 46, 25, 22, 70, 45, 30, 62, 67, 61, 40, 9, 41, 5, 30, 52, 32, 38, 8, 13, 67, 27, 40, 36, 36, 38, 31, 27, 39, 33, 72, 56, 41, 64, 51, 62, 21, 36, 51, 30, 36, 29, 33, 17, 43, 18, 38, 24, 59, 30, 36, 15, 27, 45, 14, 47, 29, 36, 51, 58, 45, 49, 61, 37, 45, 38, 58, 30, 58, 52, 29, 65, 38, 43, 18, 30, 28, 41, 42, 11, 51, 22, 57, 38, 54, 36, 55, 38, 29, 46, 35, 27, 26, 56, 47, 27, 29, 22, 38, 13, 24, 32, 42, 32, 50, 46, 35, 24, 41, 54, 43, 47, 36, 37, 30, 48, 34, 55, 38, 35, 75, 28, 12, 57, 39, 21, 18, 33, 17, 26, 48, 68, 55, 50, 50, 30, 45, 26, 37, 52, 53, 22, 73, 54, 39, 24, 26, 27, 23, 38, 41, 48, 47, 30, 36, 22, 38, 27, 26, 33, 58, 70, 68, 8, 29, 9, 19, 17, 32, 42, 50, 60, 43, 51, 25, 30, 56, 22, 70, 52, 26, 22, 53, 47, 23, 19, 61, 46, 39, 47, 11, 39, 29, 37, 70, 52, 41, 37, 36, 51, 33, 29, 41, 46, 44, 24, 24, 58, 11, 53, 34, 44, 53, 39, 52, 74, 16, 53, 46, 38, 71, 57, 26, 38, 54, 54, 40, 47, 81, 31, 52, 29, 29, 52, 64, 30, 63, 40, 26, 42, 56, 55, 36, 37, 19, 40, 51, 29, 51, 57, 45, 31, 57, 32, 27, 39, 42, 31, 23, 42, 27, 48, 31, 35, 25, 52, 58, 62, 6, 80, 29, 72, 54, 43, 48, 29, 50, 49, 19, 53, 48, 36, 35, 35, 9, 55, 37, 20, 56, 46, 50, 13, 48, 13, 18, 41, 52, 35, 33, 43, 39, 25, 31, 41, 32, 55, 28, 41, 43, 15, 66, 16, 47, 18, 40, 25, 27, 45, 39, 30, 43, 52, 44, 24, 74, 45, 36, 28, 46, 43, 7, 27, 48, 44, 80, 39, 46, 39, 31, 34, 29, 19, 8, 36, 37, 12, 43, 54, 20, 22, 31, 28, 45, 19, 40, 47, 44, 54, 32, 20, 39, 51, 61, 42, 33, 72, 38, 30, 48, 28, 36, 32, 31, 59, 38, 37, 67, 68, 14, 20, 33, 59, 44, 35, 18, 49, 53, 63, 27, 45, 41, 38, 35, 42, 13, 34, 23, 26, 64, 21, 24, 55, 42, 52, 35, 26, 24, 33, 29, 51, 50, 21, 42, 58, 48, 25, 34, 46, 21, 44, 29, 42, 43, 55, 48, 38, 54, 27, 38, 29, 29, 40, 51, 20, 66, 29, 39, 41, 23, 54, 27, 37, 44, 29, 40, 52, 18, 35, 25, 31, 41, 22, 28, 22, 55, 55, 27, 17, 69, 75, 33, 32, 65, 34, 60, 40, 39, 36, 21, 36, 59, 10, 44, 16, 41, 25, 11, 30, 33, 40, 63, 27, 38, 56, 49, 49, 33, 30, 26, 61, 28, 26, 48, 37, 42, 46, 25, 50, 21, 33, 78, 26, 19, 36, 34, 40, 33, 42, 50, 35, 33, 52, 46, 46, 28, 23, 55, 26, 30, 31, 42, 40, 63, 63, 43, 32, 42, 32, 13, 37, 53, 42, 22, 51, 61, 18, 25, 20, 36, 20, 36, 19, 41, 30, 64, 57, 38, 35, 31, 40, 46, 45, 31, 42, 24, 37, 33, 28, 53, 9, 35, 20, 30, 9, 49, 30, 52, 51, 61, 41, 11, 29, 37, 50, 49, 32, 50, 72, 49, 58, 32, 45, 30, 19, 30, 52, 16, 41, 38, 41, 41, 33, 22, 31, 44, 57, 24, 67, 52, 29, 29, 10, 56, 60, 76, 33, 69, 26, 32, 62, 18, 20, 38, 16, 50, 30, 31, 36, 40, 46, 26, 75, 34, 46, 34, 61, 28, 65, 37, 30, 62, 65, 35, 50, 27, 51, 43, 34, 32, 22, 41, 30, 35, 30, 60, 44, 50, 46, 26, 27, 39, 62, 23, 25, 36, 41, 50, 35, 36, 21, 28, 18, 58, 22, 11, 27, 26, 41, 36, 30, 60, 37, 64, 29, 56, 21, 44, 33, 49, 49, 53, 38, 41, 24, 60, 38, 26, 60, 9, 54, 42, 23, 46, 77, 23, 42, 37, 30, 23, 15, 26, 35, 21, 25, 39, 45, 28, 58, 52, 26, 34, 55, 59, 11, 21, 7, 57, 17, 28, 41, 54, 29, 38, 39, 29, 19, 39, 45, 52, 54, 40, 38, 22, 42, 46, 35, 29, 20, 35, 21, 42, 40, 32, 50, 27, 48, 68, 25, 44, 42, 64, 35, 77, 15, 32, 32, 31, 45, 52, 14, 63, 48, 17, 45, 37, 16, 21, 13, 39, 26, 29, 49, 24, 41, 39, 43, 41, 35, 34, 21, 39, 37, 23, 28, 51, 51, 27, 33, 36, 40, 49, 39, 40, 50, 41, 62, 49, 59, 39, 48, 49, 16, 39, 51, 47, 32, 51, 27, 36, 39, 28, 50, 27, 28, 18, 36, 37, 28, 23, 27, 15, 60, 49, 29, 13, 24, 32, 36, 51, 23, 27, 70, 13, 28, 57, 19, 61, 27, 60, 23, 46, 39, 43, 22, 69, 42, 30, 39, 9, 17, 53, 27, 45, 52, 29, 7, 13, 45, 45, 47, 36, 65, 49, 59, 41, 33, 26, 65, 21, 23, 19, 48, 27, 56, 38, 57, 47, 42, 63, 45, 33, 15, 22, 14, 15, 30, 51, 38, 39, 41, 48, 31, 39, 61, 29, 75, 47, 35, 58, 50, 26, 40, 53, 65, 53, 43, 44, 56, 45, 60, 40, 22, 33, 59, 53, 47, 56, 67, 47, 46, 45, 34, 75, 48, 29, 62, 24, 34, 36, 55, 31, 67, 17, 36, 29, 51, 41, 33, 25, 48, 38, 16, 63, 46, 43, 46, 45, 35, 45, 77, 35, 28, 66, 51, 20, 41, 36, 23, 65, 40, 37, 30, 51, 23, 38, 15, 63, 47, 37, 24, 18, 28, 42, 27, 44, 36, 46, 43, 41, 46, 57, 49, 43, 40, 44, 53, 23, 33, 63, 30, 32, 36, 47, 43, 35, 7, 67, 48, 33, 54, 12, 64, 57, 12, 52, 8, 58, 45, 42, 43, 54, 54, 59, 32, 35, 36, 20, 43, 40, 37, 45, 38, 41, 50, 29, 15, 34, 73, 30, 37, 55, 47, 21, 33, 37, 39, 60, 14, 52, 67, 48, 12, 37, 40, 57, 59, 64, 47, 13, 31, 57, 59, 30, 30, 22, 39, 38, 13, 32, 46, 24, 47, 16, 44, 32, 49, 28, 61, 65, 24, 24, 19, 22, 42, 20, 51, 43, 25, 27, 54, 28, 55, 36, 27, 32, 27, 55, 51, 41, 46, 37, 53, 19, 68, 44, 65, 29, 22, 55, 14, 59, 76, 50, 37, 46, 49, 38, 20, 34, 58, 52, 62, 30, 48, 45, 37, 17, 51, 33, 41, 18, 34, 17, 22, 51, 48, 14, 69, 26, 47, 54, 31, 19, 49, 49, 53, 51, 50, 69, 53, 27, 24, 33, 48, 50, 37, 42, 48, 37, 49, 68, 34, 49, 22, 44, 26, 39, 32, 43, 32, 55, 46, 73, 42, 18, 57, 53, 27, 3, 46, 51, 49, 59, 57, 26, 34, 32, 22, 47, 60, 35, 42, 28, 71, 30, 35, 52, 54, 54, 35, 35, 34, 37, 42, 70, 42, 33, 35, 56, 24, 34, 52, 54, 53, 41, 45, 24, 16, 35, 65, 38, 35, 45, 18, 46, 16, 19, 25, 34, 30, 49, 54, 28, 32, 46, 42, 30, 32, 31, 38, 28, 43, 34, 51, 52, 58, 45, 31, 59, 24, 31, 52, 33, 53, 26, 48, 45, 61, 38, 57, 36, 28, 37, 41, 40, 47, 25, 54, 17, 50, 30, 56, 26, 42, 34, 23, 19, 70, 45, 47, 68, 39, 24, 35, 56, 39, 26, 25, 22, 49, 40, 38, 32, 31, 32, 56, 48, 45, 43, 40, 58, 44, 37, 54, 40, 19, 27, 12, 41, 34, 29, 17, 86, 50, 49, 38, 22, 72, 33, 19, 47, 47, 59, 64, 62, 65, 62, 29, 49, 43, 46, 30, 70, 59, 40, 34, 52, 47, 29, 42, 31, 28, 68, 52, 24, 32, 40, 18, 35, 28, 41, 31, 58, 29, 58, 36, 31, 32, 34, 48, 66, 32, 34, 48, 35, 31, 22, 38, 23, 21, 42, 41, 34, 24, 65, 55, 29, 47, 43, 56, 38, 18, 31, 32, 54, 18, 22, 43, 67, 55, 24, 39, 49, 35, 46, 28, 28, 49, 18, 52, 28, 74, 62, 60, 59, 23, 36, 28, 61, 58, 68, 16, 25, 41, 38, 21, 51, 28, 56, 43, 38, 24, 29, 65, 37, 44, 25, 41, 40, 36, 36, 38, 57, 63, 29, 41, 51, 16, 71, 59, 14, 19, 36, 20, 31, 59, 75, 24, 36, 52, 53, 29, 50, 51, 68, 24, 49, 49, 18, 63, 57, 46, 46, 34, 63, 38, 40, 39, 46, 45, 49, 3, 73, 23, 30, 43, 63, 45, 46, 33, 20, 65, 35, 65, 65, 44, 19, 38, 14, 41, 53, 54, 61, 55, 40, 28, 53, 38, 38, 49, 65, 61, 50, 31, 42, 48, 13, 26, 64, 71, 46, 29, 25, 28, 60, 62, 48, 37, 73, 43, 21, 32, 57, 48, 20, 43, 52, 45, 47, 67, 21, 29, 32, 16, 56, 32, 71, 35, 29, 38, 52, 37, 57, 52, 19, 39, 65, 26, 33, 36, 25, 47, 40, 44, 36, 55, 28, 25, 25, 27, 44, 42, 36, 64, 24, 30, 41, 24, 30, 54, 38, 35, 43, 27, 57, 51, 34, 20, 15, 45, 34, 34, 49, 14, 28, 61, 50, 53, 69, 33, 9, 29, 55, 54, 45, 27, 51, 29, 68, 52, 52, 59, 18, 28, 21, 35, 52, 13, 19, 34, 40, 41, 33, 43, 38, 54, 66, 77, 11, 31, 51, 59, 34, 25, 66, 44, 25, 41, 21, 52, 36, 40, 26, 32, 31, 42, 52, 41, 27, 41, 25, 27, 45, 38, 48, 45, 27, 44, 31, 19, 38, 21, 57, 38, 65, 36, 57, 37, 38, 73, 48, 51, 52, 54, 37, 55, 52, 20, 37, 38, 48, 16, 45, 20, 36, 43, 51, 12, 27, 60, 46, 63, 48, 67, 31, 42, 37, 64, 21, 30, 49, 47, 41, 29, 45, 52, 35, 32, 61, 13, 36, 44, 35, 34, 40, 26, 38, 46, 48, 60, 52, 19, 29, 35, 37, 22, 61, 23, 43, 28, 27, 63, 30, 34, 52, 35, 56, 50, 37, 31, 16, 51, 39, 53, 52, 16, 24, 57, 23, 29, 26, 39, 40, 51, 53, 38, 54, 47, 35, 44, 44, 51, 29, 43, 55, 61, 39, 33, 43, 42, 51, 11, 47, 29, 67, 25, 47, 10, 66, 61, 29, 61, 20, 18, 51, 50, 36, 22, 42, 44, 43, 55, 21, 23, 28, 68, 24, 31, 70, 73, 70, 43, 16, 49, 32, 19, 56, 73, 28, 32, 39, 15, 46, 18, 42, 20, 43, 15, 65, 66, 21, 59, 27, 44, 31, 31, 38, 72, 44, 32, 46, 41, 40, 58, 33, 53, 63, 22, 16, 38, 40, 24, 61, 19, 29, 11, 18, 23, 49, 22, 20, 60, 35, 53, 28, 59, 49, 56, 27, 35, 61, 47, 61, 50, 44, 40, 22, 29, 59, 61, 59, 21, 52, 32, 44, 36, 23, 55, 42, 12, 55, 33, 46, 49, 10, 56, 25, 29, 42, 53, 55, 50, 27, 18, 22, 50, 47, 41, 54, 20, 56, 62, 18, 40, 26, 6, 62, 41, 51, 33, 36, 53, 52, 60, 17, 48, 36, 30, 27, 41, 27, 57, 14, 41, 53, 36, 44, 52, 27, 20, 44, 71, 38, 18, 35, 39, 34, 42, 17, 58, 47, 22, 28, 48, 19, 37, 38, 39, 12, 29, 61, 19, 30, 18, 31, 41, 53, 35, 32, 52, 20, 55, 35, 41, 45, 45, 35, 35, 50, 37, 29, 28, 53, 26, 55, 51, 31, 44, 25, 29, 21, 45, 42, 35, 17, 51, 34, 47, 70, 51, 48, 11, 44, 15, 64, 40, 51, 25, 47, 48, 53, 49, 47, 47, 42, 52, 50, 42, 52, 39, 48, 35, 51, 53, 34, 49, 59, 47, 45, 58, 27, 26, 22, 37, 42, 66, 46, 29, 52, 54, 34, 52, 39, 33, 52, 43, 41, 35, 46, 37, 47, 28, 40, 11, 37, 51, 55, 28, 71, 54, 48, 18, 45, 52, 41, 25, 19, 24, 54, 45, 36, 31, 31, 10, 45, 36, 41, 44, 41, 30, 65, 57, 65, 68, 24, 34, 50, 40, 56, 36, 26, 33, 71, 45, 5, 21, 50, 52, 31, 22, 30, 35, 56, 18, 28, 15, 37, 28, 37, 60, 36, 25, 26, 55, 54, 44, 55, 49, 49, 16, 42, 19, 39, 42, 46, 46, 41, 30, 28, 42, 69, 52, 32, 61, 45, 38, 9, 24, 28, 13, 26, 54, 49, 37, 47, 38, 49, 22, 55, 53, 48, 19, 46, 33, 27, 61, 31, 47, 46, 25, 25, 54, 18, 52, 38, 36, 27, 11, 42, 44, 48, 71, 42, 22, 53, 67, 26, 32, 49, 40, 32, 16, 36, 52, 27, 39, 44, 62, 85, 51, 41, 55, 64, 50, 39, 27, 38, 40, 35, 61, 24, 14, 55, 48, 49, 50, 44, 14, 17, 42, 59, 30, 38, 23, 55, 29, 34, 34, 44, 55, 28, 9, 27, 49, 49, 12, 51, 38, 44, 46, 55, 26, 42, 38, 18, 53, 70, 28, 70, 58, 41, 42, 44, 31, 46, 43, 22, 59, 22, 17, 18, 24, 32, 31, 51, 26, 14, 65, 47, 47, 55, 55, 29, 27, 55, 36, 38, 52, 36, 31, 44, 29, 29, 36, 39, 34, 22, 32, 44, 45, 22, 37, 16, 65, 46, 41, 18, 52, 48, 36, 36, 8, 60, 64, 29, 61, 35, 41, 46, 29, 34, 71, 26, 49, 42, 46, 60, 56, 35, 11, 58, 27, 42, 55, 47, 39, 28, 36, 34, 59, 38, 50, 58, 34, 59, 31, 41, 39, 14, 42, 27, 33, 34, 45, 56, 63, 46, 40, 21, 45, 34, 33, 44, 49, 35, 25, 35, 19, 62, 42, 34, 49, 63, 43, 48, 59, 55, 37, 26, 16, 82, 61, 41, 19, 11, 32, 50, 47, 55, 27, 26, 21, 28, 40, 69, 42, 45, 74, 40, 19, 38, 21, 62, 39, 31, 59, 29, 59, 27, 27, 56, 37, 35, 28, 26, 59, 39, 74, 59, 31, 56, 67, 48, 31, 28, 72, 27, 29, 36, 26, 44, 32, 39, 39, 74, 61, 34, 47, 47, 55, 21, 32, 18, 55, 24, 33, 46, 37, 56, 29, 39, 55, 41, 34, 36, 31, 48, 31, 49, 31, 63, 10, 87, 42, 38, 28, 32, 46, 29, 34, 52, 59, 21, 17, 31, 30, 57, 37, 37, 26, 46, 29, 58, 63, 18, 66, 37, 55, 53, 43, 53, 21, 47, 31, 41, 38, 26, 49, 36, 53, 37, 45, 63, 48, 13, 48, 39, 26, 35, 45, 43, 27, 49, 39, 29, 16, 49, 26, 26, 44, 45, 21, 39, 41, 52, 15, 25, 53, 36, 58, 45, 50, 32, 47, 40, 47, 38, 54, 55, 58, 48, 43, 50, 60, 43, 48, 20, 13, 32, 44, 57, 39, 12, 44, 59, 58, 33, 43, 59, 65, 58, 41, 25, 51, 33, 54, 32, 32, 34, 41, 65, 41, 48, 34, 38, 14, 54, 40, 46, 73, 18, 33, 37, 30, 42, 39, 29, 71, 29, 21, 38, 17, 45, 49, 25, 52, 35, 34, 42, 14, 40, 19, 40, 35, 45, 28, 36, 32, 64, 43, 50, 33, 27, 60, 42, 36, 36, 49, 69, 61, 41, 60, 27, 55, 25, 42, 43, 22, 39, 57, 48, 35, 53, 52, 47, 41, 27, 58, 43, 59, 27, 48, 20, 31, 52, 26, 50, 23, 75, 49, 37, 45, 57, 56, 44, 39, 34, 45, 30, 18, 35, 30, 76, 28, 51, 40, 55, 61, 67, 53, 24, 42, 42, 36, 51, 53, 71, 39, 31, 30, 42, 35, 24, 41, 65, 51, 16, 43, 47, 41, 50, 41, 24, 60, 24, 32, 48, 24, 64, 31, 60, 43, 18, 44, 41, 17, 38, 12, 34, 42, 38, 48, 7, 13, 62, 63, 13, 41, 51, 31, 34, 29, 35, 48, 38, 15, 53, 32, 70, 40, 8, 31, 22, 27, 26, 54, 16, 43, 15, 22, 42, 48, 53, 64, 63, 20, 37, 40, 36, 4, 42, 42, 43, 32, 54, 66, 72, 30, 38, 30, 35, 41, 47, 21, 18, 63, 33, 31, 39, 59, 42, 20, 47, 27, 47, 59, 22, 34, 45, 14, 63, 40, 54, 25, 19, 44, 46, 60, 55, 47, 48, 16, 34, 37, 49, 22, 34, 17, 17, 59, 25, 44, 39, 47, 31, 40, 38, 50, 50, 50, 46, 45, 38, 39, 23, 12, 21, 47, 15, 37, 38, 20, 27, 58, 37, 70, 28, 18, 41, 12, 29, 30, 47, 27, 50, 29, 39, 17, 31, 17, 41, 29, 50, 42, 65, 32, 13, 17, 34, 54, 32, 48, 39, 67, 56, 15, 41, 36, 39, 28, 30, 45, 45, 34, 46, 30, 40, 56, 48, 26, 43, 22, 61, 31, 28, 29, 50, 16, 65, 54, 44, 52, 28, 32, 19, 42, 42, 39, 39, 59, 28, 60, 66, 23, 31, 24, 28, 13, 60, 38, 27, 35, 48, 59, 40, 62, 46, 70, 25, 54, 50, 32, 46, 57, 40, 38, 11, 45, 53, 21, 50, 30, 40, 43, 16, 32, 51, 42, 49, 60, 60, 37, 44, 73, 45, 55, 33, 42, 31, 49, 44, 21, 62, 50, 58, 26, 17, 71, 17, 27, 39, 50, 40, 43, 44, 31, 21, 44, 43, 22, 60, 29, 57, 20, 39, 44, 33, 34, 34, 41, 16, 25, 51, 23, 48, 17, 34, 24, 40, 27, 39, 28, 24, 26, 36, 37, 23, 57, 29, 56, 23, 41, 67, 35, 23, 10, 69, 56, 53, 50, 45, 32, 52, 39, 42, 30, 36, 47, 47, 36, 21, 21, 51, 24, 72, 10, 17, 52, 39, 39, 19, 20, 36, 54, 36, 34, 49, 63, 37, 24, 21, 43, 28, 65, 32, 29, 38, 23, 31, 9, 44, 51, 26, 52, 54, 28, 52, 46, 32, 50, 43, 46, 40, 24, 42, 38, 24, 46, 44, 40, 29, 35, 27, 55, 32, 28, 23, 13, 33, 31, 37, 18, 19, 37, 42, 18, 24, 36, 25, 54, 65, 6, 43, 27, 37, 68, 42, 33, 41, 48, 45, 66, 15, 27, 34]}, 'test_4': {'capacity': 100, 'num_items': 5000, 'items': [38, 34, 46, 40, 59, 55, 27, 37, 11, 63, 9, 31, 18, 52, 43, 50, 47, 34, 44, 47, 50, 41, 17, 40, 52, 55, 27, 29, 28, 54, 13, 57, 40, 15, 35, 27, 13, 28, 20, 8, 24, 47, 38, 48, 26, 34, 36, 47, 39, 10, 19, 57, 39, 44, 43, 56, 31, 48, 50, 26, 52, 52, 56, 41, 49, 37, 46, 37, 29, 47, 43, 30, 32, 24, 47, 37, 55, 47, 43, 10, 50, 27, 50, 27, 33, 51, 15, 43, 45, 48, 44, 59, 32, 44, 40, 46, 66, 39, 51, 30, 38, 25, 38, 28, 48, 50, 14, 41, 39, 31, 33, 38, 17, 24, 32, 23, 18, 55, 41, 40, 66, 35, 51, 63, 50, 88, 31, 63, 34, 51, 58, 32, 43, 59, 65, 43, 40, 31, 47, 66, 47, 45, 61, 24, 43, 53, 37, 36, 57, 19, 51, 6, 29, 41, 30, 11, 25, 50, 53, 53, 52, 42, 22, 29, 39, 25, 25, 34, 52, 50, 42, 59, 42, 50, 52, 49, 22, 60, 37, 50, 45, 24, 30, 40, 64, 33, 64, 47, 26, 55, 29, 39, 60, 27, 34, 41, 43, 35, 49, 40, 39, 51, 33, 45, 48, 64, 19, 47, 23, 41, 53, 35, 43, 33, 39, 34, 63, 27, 42, 34, 54, 52, 74, 27, 59, 71, 56, 33, 41, 16, 74, 34, 38, 41, 29, 30, 28, 28, 51, 29, 53, 27, 6, 15, 35, 63, 16, 52, 43, 21, 41, 21, 36, 32, 52, 39, 32, 25, 37, 52, 58, 21, 32, 35, 61, 52, 23, 58, 36, 19, 51, 61, 42, 40, 30, 34, 25, 28, 28, 19, 20, 30, 34, 63, 30, 53, 49, 24, 20, 54, 45, 18, 52, 49, 43, 37, 33, 44, 42, 43, 50, 33, 25, 29, 64, 43, 63, 45, 58, 59, 50, 73, 48, 34, 8, 26, 50, 21, 80, 24, 36, 26, 37, 65, 53, 50, 50, 60, 33, 81, 43, 57, 25, 67, 35, 35, 47, 52, 14, 60, 36, 27, 52, 24, 37, 44, 57, 42, 33, 37, 39, 43, 58, 44, 35, 46, 50, 47, 74, 25, 46, 27, 53, 54, 37, 46, 39, 27, 32, 49, 77, 37, 68, 34, 63, 56, 44, 45, 26, 74, 47, 52, 37, 37, 67, 26, 28, 39, 49, 25, 34, 40, 30, 56, 47, 50, 56, 32, 26, 50, 51, 40, 27, 61, 54, 42, 25, 43, 17, 41, 49, 26, 51, 22, 15, 52, 50, 31, 28, 31, 55, 32, 20, 33, 54, 49, 32, 42, 68, 47, 64, 6, 37, 38, 44, 37, 25, 9, 60, 44, 38, 40, 62, 48, 49, 55, 40, 55, 41, 40, 42, 51, 46, 61, 54, 45, 34, 48, 80, 63, 28, 31, 41, 49, 30, 41, 13, 48, 65, 59, 33, 42, 24, 48, 48, 30, 75, 43, 62, 60, 65, 15, 19, 33, 47, 36, 21, 31, 41, 23, 38, 51, 42, 58, 14, 42, 12, 20, 37, 35, 42, 43, 15, 43, 28, 42, 34, 55, 35, 43, 49, 28, 16, 40, 26, 27, 41, 35, 27, 46, 38, 31, 36, 21, 35, 64, 35, 33, 42, 13, 49, 51, 59, 53, 18, 27, 67, 20, 38, 26, 37, 33, 44, 31, 21, 23, 46, 38, 36, 65, 39, 52, 35, 42, 30, 38, 33, 45, 72, 21, 35, 54, 29, 57, 52, 33, 20, 30, 45, 33, 53, 73, 48, 49, 32, 36, 62, 66, 30, 56, 53, 29, 42, 24, 46, 39, 20, 43, 38, 52, 25, 58, 22, 38, 44, 48, 34, 40, 32, 8, 35, 45, 25, 68, 30, 45, 67, 56, 40, 22, 30, 74, 27, 48, 33, 67, 39, 11, 37, 53, 45, 57, 42, 45, 50, 47, 40, 40, 61, 64, 51, 28, 18, 12, 49, 43, 47, 44, 55, 31, 53, 37, 31, 47, 48, 31, 39, 42, 50, 14, 33, 42, 39, 50, 37, 55, 47, 50, 78, 37, 38, 30, 61, 39, 48, 30, 26, 48, 62, 46, 27, 54, 38, 36, 46, 34, 35, 64, 24, 39, 75, 29, 70, 38, 28, 39, 10, 24, 49, 47, 33, 47, 58, 30, 10, 26, 28, 43, 33, 29, 46, 36, 35, 19, 36, 10, 37, 31, 7, 42, 46, 63, 82, 49, 42, 42, 22, 54, 42, 50, 30, 51, 61, 48, 43, 29, 13, 33, 36, 58, 38, 47, 59, 57, 19, 33, 56, 7, 49, 41, 49, 11, 40, 68, 28, 11, 36, 39, 26, 26, 64, 25, 36, 18, 53, 33, 39, 45, 62, 30, 23, 38, 31, 26, 35, 26, 4, 44, 39, 34, 29, 23, 36, 62, 39, 41, 38, 14, 55, 19, 46, 57, 51, 37, 19, 27, 33, 36, 34, 38, 43, 27, 66, 30, 27, 46, 48, 48, 59, 81, 58, 40, 50, 35, 45, 51, 53, 53, 46, 52, 39, 17, 49, 35, 32, 41, 54, 46, 33, 42, 44, 24, 43, 45, 28, 29, 44, 44, 34, 46, 44, 17, 54, 27, 39, 42, 41, 26, 39, 57, 38, 17, 21, 52, 47, 24, 32, 37, 45, 13, 62, 48, 31, 42, 19, 23, 30, 50, 15, 31, 28, 42, 51, 45, 47, 23, 40, 52, 85, 54, 36, 20, 38, 34, 18, 25, 14, 34, 43, 21, 35, 39, 45, 33, 52, 24, 40, 51, 29, 26, 51, 41, 64, 57, 29, 45, 48, 35, 37, 38, 42, 46, 36, 43, 26, 41, 62, 62, 63, 6, 21, 30, 30, 21, 36, 33, 58, 41, 53, 29, 42, 9, 57, 27, 37, 48, 25, 23, 31, 33, 32, 42, 35, 15, 13, 61, 30, 16, 47, 25, 31, 62, 5, 50, 19, 38, 61, 27, 26, 35, 40, 24, 31, 30, 18, 18, 41, 36, 61, 11, 46, 7, 8, 42, 39, 28, 28, 33, 37, 37, 44, 6, 53, 35, 29, 35, 67, 29, 31, 49, 34, 46, 21, 23, 35, 48, 28, 38, 67, 45, 59, 44, 50, 61, 24, 49, 58, 9, 16, 40, 14, 18, 34, 47, 37, 56, 22, 41, 39, 35, 59, 57, 34, 24, 16, 48, 36, 38, 44, 23, 79, 24, 10, 36, 51, 32, 39, 43, 55, 28, 27, 25, 42, 45, 63, 24, 41, 47, 19, 32, 26, 57, 30, 24, 32, 62, 73, 35, 65, 30, 67, 38, 41, 30, 37, 48, 22, 58, 50, 8, 42, 44, 72, 42, 67, 24, 64, 55, 54, 42, 13, 13, 27, 27, 19, 53, 28, 33, 23, 36, 70, 54, 55, 37, 56, 35, 35, 53, 3, 43, 26, 43, 29, 69, 45, 61, 45, 46, 19, 40, 25, 43, 38, 62, 45, 58, 71, 45, 28, 42, 42, 11, 56, 58, 39, 35, 66, 23, 30, 42, 35, 50, 24, 44, 61, 56, 42, 41, 56, 48, 54, 21, 35, 51, 21, 29, 16, 44, 40, 50, 34, 38, 63, 58, 20, 51, 30, 39, 33, 29, 7, 39, 36, 59, 16, 45, 54, 49, 73, 30, 55, 32, 53, 83, 28, 44, 38, 54, 32, 23, 30, 50, 12, 52, 52, 46, 28, 47, 32, 26, 8, 60, 9, 36, 27, 27, 69, 49, 45, 31, 16, 48, 14, 31, 36, 44, 35, 48, 47, 51, 55, 40, 43, 42, 21, 51, 70, 53, 18, 37, 37, 53, 26, 28, 53, 65, 33, 27, 17, 42, 32, 19, 65, 31, 13, 32, 42, 24, 45, 54, 51, 48, 45, 54, 60, 31, 62, 43, 43, 43, 58, 33, 9, 46, 43, 16, 77, 52, 55, 46, 70, 78, 35, 42, 27, 24, 62, 40, 41, 43, 60, 43, 46, 27, 54, 47, 49, 51, 35, 42, 46, 21, 37, 47, 13, 39, 42, 21, 24, 45, 11, 50, 29, 36, 43, 49, 46, 28, 36, 47, 49, 42, 35, 57, 44, 41, 51, 59, 68, 37, 40, 32, 67, 21, 35, 28, 36, 35, 60, 39, 35, 39, 13, 51, 24, 8, 21, 59, 34, 42, 33, 41, 44, 22, 35, 33, 45, 80, 36, 42, 26, 25, 45, 46, 23, 30, 27, 53, 58, 50, 71, 39, 35, 49, 18, 56, 43, 16, 51, 24, 60, 53, 57, 51, 27, 34, 49, 47, 55, 37, 13, 11, 34, 53, 21, 24, 29, 61, 56, 45, 15, 33, 40, 31, 18, 36, 44, 9, 20, 41, 48, 34, 38, 35, 65, 48, 18, 11, 37, 28, 39, 51, 59, 42, 54, 44, 41, 10, 30, 54, 44, 38, 22, 44, 11, 54, 30, 40, 50, 49, 34, 26, 33, 39, 31, 44, 51, 47, 40, 41, 9, 42, 28, 45, 28, 36, 47, 50, 7, 47, 64, 43, 44, 46, 46, 11, 45, 26, 29, 31, 61, 44, 53, 71, 31, 69, 6, 42, 38, 51, 34, 51, 38, 45, 27, 29, 32, 25, 32, 25, 36, 43, 56, 49, 36, 36, 60, 46, 24, 36, 45, 57, 56, 41, 43, 35, 18, 52, 33, 41, 66, 71, 25, 28, 17, 11, 40, 34, 34, 12, 38, 31, 24, 52, 39, 19, 66, 55, 24, 43, 24, 33, 39, 66, 30, 24, 8, 62, 55, 64, 40, 59, 53, 42, 52, 29, 26, 24, 40, 32, 43, 30, 38, 55, 39, 16, 27, 33, 58, 31, 66, 35, 30, 26, 18, 34, 50, 35, 23, 30, 36, 36, 21, 33, 46, 52, 48, 31, 30, 29, 9, 27, 26, 40, 39, 45, 38, 60, 40, 34, 49, 45, 78, 34, 29, 56, 38, 20, 83, 19, 34, 37, 33, 54, 69, 47, 32, 49, 45, 48, 42, 19, 44, 30, 21, 39, 30, 29, 67, 37, 29, 33, 74, 38, 36, 10, 26, 27, 26, 49, 57, 56, 26, 34, 33, 9, 20, 22, 36, 53, 16, 69, 28, 35, 58, 53, 9, 50, 43, 30, 58, 49, 39, 40, 27, 42, 40, 42, 19, 39, 46, 58, 62, 30, 48, 30, 39, 36, 17, 37, 51, 18, 56, 48, 18, 24, 39, 21, 48, 8, 45, 36, 42, 44, 38, 50, 40, 51, 27, 23, 47, 16, 62, 49, 37, 44, 50, 17, 45, 45, 68, 12, 22, 59, 54, 38, 11, 43, 51, 21, 34, 29, 49, 41, 17, 33, 78, 18, 30, 47, 71, 33, 56, 44, 55, 46, 48, 50, 45, 31, 45, 27, 50, 46, 36, 43, 40, 59, 52, 53, 44, 29, 33, 59, 29, 55, 48, 38, 38, 21, 52, 22, 35, 38, 19, 31, 51, 47, 52, 41, 29, 26, 28, 60, 27, 40, 61, 44, 39, 36, 34, 37, 37, 39, 48, 73, 26, 24, 34, 29, 32, 59, 40, 41, 31, 14, 63, 19, 38, 45, 40, 58, 27, 55, 66, 45, 31, 28, 51, 22, 31, 15, 16, 31, 29, 34, 55, 52, 33, 46, 43, 70, 44, 40, 33, 31, 28, 52, 22, 37, 61, 17, 15, 21, 42, 54, 35, 25, 63, 15, 38, 52, 49, 58, 39, 65, 32, 31, 52, 43, 46, 44, 51, 34, 43, 56, 60, 80, 10, 46, 18, 17, 25, 37, 33, 34, 61, 31, 44, 64, 22, 30, 22, 35, 57, 38, 37, 42, 56, 39, 54, 25, 57, 52, 58, 36, 27, 36, 43, 24, 50, 60, 36, 16, 26, 18, 62, 50, 19, 39, 15, 34, 27, 49, 33, 22, 49, 45, 33, 43, 39, 65, 20, 44, 58, 42, 24, 38, 36, 23, 37, 41, 35, 33, 10, 31, 58, 59, 24, 36, 39, 61, 27, 43, 34, 37, 37, 31, 55, 44, 28, 11, 48, 34, 56, 41, 67, 51, 35, 26, 40, 22, 31, 46, 36, 21, 29, 22, 37, 31, 30, 68, 37, 47, 37, 33, 31, 72, 48, 33, 40, 44, 47, 52, 20, 25, 61, 27, 33, 57, 61, 46, 17, 29, 15, 68, 31, 35, 24, 54, 42, 24, 9, 12, 48, 52, 43, 43, 42, 23, 57, 53, 75, 36, 59, 46, 40, 38, 37, 51, 52, 30, 62, 41, 41, 71, 57, 20, 40, 51, 26, 60, 46, 57, 12, 9, 47, 26, 30, 30, 51, 27, 20, 47, 64, 36, 32, 34, 68, 31, 34, 18, 42, 24, 25, 17, 20, 78, 61, 47, 61, 19, 42, 27, 28, 52, 35, 14, 37, 51, 44, 44, 57, 48, 49, 46, 23, 41, 39, 37, 45, 70, 38, 30, 16, 36, 45, 26, 53, 29, 39, 29, 59, 28, 42, 31, 60, 52, 18, 34, 38, 52, 32, 40, 60, 81, 58, 55, 19, 28, 62, 54, 52, 35, 13, 9, 26, 26, 70, 49, 25, 30, 33, 12, 54, 29, 32, 51, 30, 64, 54, 28, 39, 23, 31, 22, 38, 40, 54, 42, 75, 34, 15, 33, 63, 37, 32, 21, 34, 47, 47, 39, 39, 49, 33, 31, 49, 43, 45, 55, 62, 39, 17, 53, 47, 39, 42, 22, 47, 64, 29, 17, 34, 24, 34, 47, 4, 32, 54, 63, 52, 32, 31, 43, 38, 36, 34, 21, 46, 60, 35, 25, 40, 18, 36, 50, 34, 27, 73, 48, 31, 48, 37, 19, 24, 61, 20, 36, 60, 32, 25, 39, 40, 38, 52, 21, 7, 52, 79, 60, 58, 57, 50, 50, 27, 40, 45, 21, 36, 28, 23, 38, 41, 35, 42, 6, 26, 23, 36, 19, 59, 41, 28, 45, 45, 57, 33, 55, 63, 42, 19, 35, 47, 17, 44, 31, 11, 7, 15, 36, 66, 42, 19, 41, 40, 30, 49, 49, 55, 51, 48, 21, 51, 39, 32, 42, 38, 61, 44, 26, 12, 25, 28, 52, 14, 56, 23, 47, 36, 51, 25, 31, 43, 34, 58, 25, 30, 34, 24, 90, 49, 36, 20, 55, 49, 43, 22, 64, 76, 33, 57, 50, 28, 42, 40, 23, 56, 39, 27, 23, 40, 47, 38, 49, 52, 39, 39, 43, 17, 44, 28, 43, 49, 53, 70, 31, 48, 63, 29, 25, 31, 45, 29, 40, 43, 46, 17, 27, 60, 56, 53, 54, 66, 30, 44, 29, 46, 32, 22, 40, 28, 34, 37, 19, 51, 42, 26, 19, 28, 66, 36, 33, 62, 23, 70, 62, 54, 49, 44, 39, 59, 58, 60, 39, 75, 41, 59, 33, 63, 51, 53, 38, 28, 52, 80, 39, 50, 29, 63, 48, 54, 32, 19, 11, 55, 27, 39, 36, 33, 18, 39, 15, 38, 23, 35, 46, 34, 31, 25, 26, 55, 30, 32, 22, 56, 45, 39, 31, 21, 28, 68, 36, 35, 45, 17, 36, 47, 23, 37, 17, 42, 53, 37, 42, 53, 45, 23, 34, 30, 26, 42, 39, 31, 43, 62, 55, 40, 75, 37, 41, 40, 26, 35, 26, 65, 18, 41, 37, 31, 43, 60, 62, 44, 42, 74, 41, 51, 30, 40, 49, 52, 55, 36, 22, 41, 50, 19, 53, 11, 32, 24, 18, 34, 62, 47, 39, 35, 34, 32, 35, 23, 36, 28, 37, 48, 65, 46, 57, 7, 26, 69, 38, 58, 50, 47, 38, 21, 50, 35, 45, 40, 46, 36, 48, 58, 36, 30, 54, 38, 56, 24, 44, 35, 30, 33, 27, 81, 44, 80, 45, 49, 38, 19, 23, 30, 27, 40, 71, 35, 67, 18, 33, 73, 46, 33, 44, 51, 31, 52, 44, 57, 51, 26, 27, 67, 23, 14, 36, 34, 41, 40, 55, 23, 37, 18, 21, 26, 43, 33, 42, 53, 21, 35, 52, 51, 30, 48, 30, 37, 50, 46, 8, 43, 30, 54, 53, 35, 58, 38, 47, 35, 8, 52, 38, 37, 81, 29, 43, 55, 37, 25, 49, 41, 39, 32, 38, 46, 59, 18, 46, 46, 44, 14, 35, 50, 49, 16, 33, 44, 36, 42, 77, 33, 36, 51, 39, 18, 58, 10, 43, 58, 60, 55, 41, 25, 63, 20, 39, 69, 29, 30, 65, 59, 23, 50, 25, 33, 36, 31, 44, 23, 54, 8, 49, 14, 31, 39, 61, 58, 32, 59, 37, 32, 57, 26, 38, 64, 61, 45, 37, 39, 45, 36, 28, 41, 38, 28, 20, 37, 57, 30, 36, 53, 42, 58, 26, 45, 18, 74, 53, 48, 52, 23, 49, 20, 35, 8, 27, 38, 65, 28, 7, 48, 29, 48, 50, 37, 41, 56, 36, 43, 44, 30, 32, 21, 48, 40, 29, 52, 56, 37, 57, 34, 16, 54, 20, 56, 33, 16, 38, 25, 74, 20, 52, 25, 60, 50, 29, 44, 60, 35, 32, 41, 42, 26, 43, 25, 30, 36, 31, 23, 48, 14, 29, 32, 59, 41, 32, 27, 23, 34, 41, 30, 46, 66, 52, 66, 31, 39, 25, 78, 24, 47, 33, 54, 7, 34, 56, 28, 33, 31, 40, 31, 15, 62, 42, 47, 44, 43, 25, 35, 32, 45, 6, 45, 20, 65, 13, 29, 47, 49, 43, 37, 51, 38, 50, 52, 48, 40, 55, 49, 23, 42, 38, 18, 21, 45, 56, 37, 33, 28, 50, 46, 43, 34, 67, 27, 22, 33, 44, 37, 27, 50, 46, 37, 14, 49, 24, 53, 34, 26, 54, 27, 35, 46, 45, 78, 18, 41, 25, 29, 30, 17, 17, 7, 50, 21, 69, 49, 61, 15, 35, 33, 7, 27, 20, 32, 45, 40, 54, 18, 15, 54, 42, 50, 41, 69, 45, 48, 49, 59, 27, 26, 63, 66, 35, 32, 50, 18, 31, 51, 62, 57, 59, 19, 47, 51, 32, 44, 65, 26, 43, 60, 65, 33, 50, 22, 32, 34, 45, 59, 90, 68, 52, 38, 37, 25, 46, 49, 29, 15, 46, 26, 36, 37, 50, 35, 29, 23, 31, 19, 68, 37, 34, 33, 49, 65, 43, 41, 52, 35, 37, 30, 30, 37, 30, 41, 58, 22, 36, 66, 43, 50, 49, 29, 39, 42, 70, 20, 30, 62, 41, 29, 29, 45, 38, 59, 46, 5, 31, 52, 44, 51, 60, 45, 33, 50, 40, 39, 46, 45, 63, 32, 53, 53, 43, 31, 34, 69, 36, 61, 18, 28, 26, 38, 31, 19, 55, 42, 53, 39, 62, 29, 55, 59, 22, 53, 29, 46, 39, 26, 26, 61, 38, 26, 50, 59, 53, 52, 42, 24, 25, 54, 15, 48, 43, 37, 31, 51, 26, 59, 37, 66, 68, 39, 39, 47, 28, 45, 42, 57, 41, 66, 21, 25, 58, 29, 40, 28, 27, 78, 39, 44, 27, 67, 63, 35, 63, 22, 49, 26, 44, 36, 34, 34, 38, 42, 44, 43, 41, 52, 7, 20, 51, 38, 50, 58, 35, 36, 27, 35, 48, 34, 67, 20, 48, 31, 40, 14, 65, 45, 75, 35, 32, 24, 46, 44, 30, 20, 50, 17, 38, 58, 60, 24, 53, 51, 56, 44, 65, 18, 52, 32, 35, 56, 37, 42, 48, 54, 48, 18, 22, 42, 32, 40, 39, 40, 41, 57, 53, 36, 26, 34, 26, 61, 42, 54, 50, 46, 56, 34, 43, 33, 41, 35, 20, 16, 32, 54, 50, 54, 60, 70, 24, 35, 47, 30, 13, 31, 46, 41, 36, 44, 48, 32, 33, 33, 56, 51, 39, 30, 46, 41, 54, 39, 48, 46, 43, 26, 34, 27, 43, 25, 57, 61, 62, 19, 47, 23, 27, 36, 48, 47, 58, 60, 23, 36, 31, 32, 10, 44, 46, 33, 49, 31, 67, 24, 40, 52, 15, 40, 44, 28, 48, 37, 40, 39, 45, 34, 50, 47, 29, 44, 20, 54, 35, 30, 51, 35, 44, 34, 54, 48, 35, 51, 28, 52, 36, 18, 40, 55, 19, 62, 58, 31, 22, 19, 32, 59, 42, 30, 32, 51, 67, 20, 38, 33, 94, 37, 59, 69, 61, 33, 35, 40, 43, 33, 28, 38, 48, 52, 43, 21, 55, 64, 38, 57, 47, 34, 39, 35, 40, 67, 34, 35, 64, 25, 21, 31, 41, 44, 24, 49, 54, 32, 23, 64, 64, 32, 37, 55, 45, 38, 45, 34, 35, 36, 35, 41, 29, 34, 55, 34, 45, 18, 48, 38, 24, 35, 45, 49, 34, 57, 34, 51, 57, 21, 47, 53, 64, 40, 54, 58, 14, 51, 63, 29, 56, 41, 64, 25, 21, 40, 75, 13, 50, 34, 45, 50, 65, 32, 42, 19, 41, 33, 18, 26, 35, 50, 40, 22, 34, 44, 55, 56, 10, 31, 13, 39, 20, 47, 12, 44, 52, 41, 43, 52, 31, 49, 35, 37, 58, 20, 17, 14, 38, 59, 27, 56, 21, 36, 54, 35, 26, 17, 26, 50, 32, 58, 37, 60, 57, 52, 42, 15, 54, 21, 18, 40, 48, 29, 38, 42, 48, 21, 46, 41, 48, 19, 20, 36, 21, 36, 49, 53, 16, 53, 22, 25, 62, 45, 23, 28, 30, 63, 44, 23, 37, 28, 22, 65, 43, 60, 21, 8, 25, 28, 52, 58, 46, 59, 4, 47, 64, 23, 35, 31, 33, 50, 45, 45, 24, 46, 51, 52, 68, 47, 19, 48, 63, 30, 38, 25, 41, 40, 59, 40, 23, 41, 27, 71, 30, 31, 73, 72, 52, 49, 30, 58, 53, 32, 72, 44, 45, 52, 43, 66, 43, 48, 17, 41, 27, 72, 24, 20, 63, 42, 36, 13, 41, 67, 40, 41, 34, 30, 39, 23, 38, 26, 46, 19, 26, 65, 46, 20, 31, 32, 49, 60, 58, 41, 9, 18, 29, 54, 34, 47, 51, 28, 44, 52, 44, 22, 56, 30, 52, 14, 41, 71, 50, 27, 15, 44, 25, 43, 39, 38, 58, 39, 51, 49, 27, 50, 52, 31, 17, 44, 45, 15, 42, 34, 51, 53, 55, 18, 66, 61, 22, 22, 36, 27, 64, 13, 76, 65, 36, 22, 30, 42, 57, 34, 52, 17, 58, 71, 39, 75, 24, 44, 18, 37, 64, 45, 23, 16, 22, 49, 46, 33, 46, 39, 41, 35, 30, 37, 25, 24, 47, 65, 20, 43, 55, 71, 27, 21, 55, 55, 48, 46, 8, 46, 46, 34, 19, 54, 58, 52, 42, 28, 13, 66, 33, 43, 21, 51, 55, 41, 43, 44, 48, 17, 22, 41, 39, 44, 53, 20, 32, 39, 64, 27, 50, 44, 43, 51, 34, 24, 26, 61, 42, 17, 45, 37, 60, 30, 22, 23, 44, 43, 33, 55, 29, 32, 31, 31, 51, 65, 80, 43, 57, 44, 29, 24, 12, 64, 42, 52, 24, 51, 22, 39, 42, 55, 33, 48, 47, 62, 31, 46, 14, 25, 55, 34, 21, 29, 47, 44, 21, 44, 58, 59, 24, 29, 38, 51, 39, 25, 44, 37, 62, 13, 48, 48, 39, 43, 12, 6, 52, 27, 47, 44, 34, 54, 42, 49, 38, 34, 35, 62, 35, 36, 49, 32, 19, 48, 61, 32, 57, 58, 27, 52, 44, 39, 26, 23, 42, 45, 56, 55, 52, 35, 38, 31, 31, 28, 20, 40, 48, 44, 40, 71, 63, 48, 44, 52, 47, 35, 63, 62, 25, 37, 35, 35, 39, 32, 43, 45, 58, 68, 25, 37, 50, 48, 30, 51, 31, 28, 52, 63, 50, 81, 36, 59, 48, 44, 27, 18, 19, 26, 54, 54, 39, 43, 24, 40, 13, 39, 22, 23, 29, 53, 34, 23, 61, 56, 43, 49, 48, 49, 42, 9, 27, 33, 39, 29, 26, 53, 46, 46, 43, 41, 28, 34, 29, 33, 43, 44, 15, 41, 30, 32, 55, 75, 50, 26, 55, 68, 15, 17, 22, 55, 33, 52, 23, 39, 39, 39, 74, 18, 21, 37, 36, 23, 64, 51, 20, 65, 38, 25, 68, 58, 33, 53, 27, 25, 59, 35, 49, 51, 28, 38, 40, 36, 27, 46, 24, 17, 47, 38, 64, 52, 18, 32, 20, 27, 48, 37, 46, 77, 10, 39, 33, 48, 29, 38, 37, 41, 81, 39, 19, 54, 46, 33, 60, 29, 52, 40, 14, 54, 38, 27, 34, 41, 37, 34, 57, 18, 23, 36, 31, 73, 39, 40, 33, 31, 22, 35, 36, 50, 28, 41, 31, 18, 38, 53, 27, 43, 33, 29, 34, 36, 48, 18, 39, 38, 27, 47, 51, 68, 44, 39, 16, 29, 54, 16, 42, 38, 43, 33, 25, 27, 56, 57, 57, 50, 59, 42, 46, 58, 48, 52, 37, 10, 25, 63, 18, 49, 26, 32, 23, 31, 47, 28, 11, 32, 54, 17, 66, 27, 31, 30, 50, 49, 36, 20, 32, 72, 30, 27, 14, 58, 40, 41, 51, 39, 48, 19, 49, 58, 58, 50, 54, 40, 29, 30, 33, 33, 44, 39, 39, 32, 37, 45, 38, 48, 28, 41, 40, 53, 52, 29, 38, 44, 57, 22, 39, 24, 45, 20, 38, 53, 43, 38, 54, 40, 35, 17, 53, 18, 34, 44, 18, 38, 55, 48, 46, 35, 26, 21, 34, 62, 53, 46, 30, 6, 18, 63, 56, 15, 58, 68, 47, 49, 47, 43, 26, 42, 31, 28, 42, 18, 35, 66, 45, 53, 67, 41, 31, 34, 48, 42, 57, 40, 47, 16, 67, 45, 61, 8, 12, 44, 74, 35, 41, 40, 37, 38, 46, 37, 56, 32, 57, 25, 51, 48, 47, 31, 60, 15, 64, 39, 46, 37, 38, 10, 48, 31, 62, 13, 26, 34, 33, 53, 61, 28, 67, 8, 33, 24, 32, 26, 66, 35, 52, 32, 43, 43, 27, 45, 34, 33, 35, 51, 33, 48, 39, 33, 40, 20, 30, 32, 34, 71, 62, 29, 54, 31, 24, 47, 11, 22, 18, 34, 41, 36, 65, 41, 35, 63, 27, 29, 44, 38, 13, 36, 23, 25, 40, 55, 47, 49, 46, 36, 53, 38, 16, 13, 28, 63, 28, 49, 15, 46, 12, 24, 50, 24, 49, 61, 79, 37, 21, 45, 33, 38, 38, 30, 49, 48, 52, 49, 45, 48, 9, 47, 49, 44, 49, 28, 28, 43, 10, 46, 52, 15, 51, 45, 54, 30, 10, 50, 25, 44, 25, 53, 50, 13, 65, 20, 66, 25, 39, 10, 40, 10, 38, 50, 36, 30, 51, 46, 53, 31, 41, 42, 35, 62, 51, 14, 33, 37, 57, 43, 56, 21, 22, 50, 41, 50, 27, 32, 11, 49, 56, 23, 54, 32, 46, 44, 29, 31, 25, 19, 50, 37, 46, 47, 48, 51, 20, 43, 57, 33, 44, 46, 70, 34, 45, 13, 36, 53, 28, 50, 10, 48, 27, 19, 52, 22, 51, 49, 65, 21, 40, 40, 18, 53, 27, 38, 37, 32, 74, 52, 23, 40, 54, 55, 51, 61, 34, 37, 43, 33, 33, 73, 48, 46, 48, 54, 49, 20, 33, 37, 43, 15, 36, 42, 40, 29, 43, 18, 31, 56, 36, 24, 57, 48, 67, 20, 16, 15, 62, 35, 53, 36, 43, 35, 35, 51, 62, 53, 66, 44, 34, 50, 34, 40, 58, 44, 52, 25, 30, 23, 52, 32, 50, 27, 28, 48, 30, 53, 50, 50, 35, 15, 22, 19, 45, 51, 22, 39, 36, 49, 61, 57, 58, 40, 43, 81, 79, 54, 41, 20, 22, 37, 12, 34, 61, 23, 37, 57, 36, 38, 43, 30, 60, 20, 45, 35, 32, 23, 27, 33, 30, 22, 24, 51, 23, 26, 35, 10, 70, 48, 38, 11, 24, 67, 32, 24, 62, 49, 24, 30, 49, 51, 31, 32, 14, 59, 50, 51, 30, 68, 38, 19, 37, 34, 46, 37, 63, 32, 21, 41, 43, 24, 41, 67, 26, 36, 46, 54, 61, 49, 35, 16, 16, 16, 56, 41, 41, 17, 40, 12, 46, 48, 19, 73, 31, 11, 52, 50, 26, 41, 55, 35, 23, 56, 22, 33, 60, 44, 23, 40, 23, 31, 43, 46, 26, 40, 40, 56, 29, 33, 24, 20, 53, 62, 22, 51, 68, 62, 56, 30, 56, 49, 64, 35, 39, 29, 36, 47, 24, 74, 36, 39, 54, 18, 21, 55, 34, 70, 24, 37, 31, 39, 63, 11, 42, 61, 31, 62, 46, 25, 38, 19, 53, 33, 26, 23, 52, 52, 36, 30, 10, 48, 58, 26, 29, 16, 23, 34, 22, 15, 26, 42, 15, 18, 46, 59, 58, 30, 42, 49, 16, 14, 50, 29, 27, 41, 48, 59, 42, 32, 33, 43, 43, 53, 52, 43, 63, 44, 19, 46, 43, 34, 50, 50, 23, 37, 36, 76, 50, 49, 54, 40, 35, 52, 42, 15, 32, 27, 22, 36, 26, 62, 31, 37, 50, 59, 35, 28, 18, 33, 39, 56, 44, 53, 39, 13, 12, 42, 44, 56, 58, 45, 31, 44, 74, 28, 46, 44, 31, 36, 40, 35, 41, 23, 34, 27, 27, 64, 39, 31, 51, 15, 38, 58, 41, 30, 31, 56, 44, 43, 41, 31, 10, 56, 66, 19, 54, 43, 35, 50, 40, 43, 50, 39, 19, 29, 17, 16, 46, 33, 11, 38, 47, 47, 33, 21, 45, 35, 37, 78, 69, 42, 59, 50, 30, 43, 50, 49, 29, 61, 46, 62, 25, 39, 67, 32, 43, 21, 26, 16, 26, 18, 55, 37, 33, 23, 33, 45, 47, 32, 51, 45, 23, 56, 49, 75, 28, 21, 34, 28, 40, 47, 34, 37, 43, 25, 31, 56, 65, 38, 14, 25, 33, 20, 7, 40, 39, 25, 56, 28, 51, 24, 52, 35, 46, 57, 52, 38, 56, 31, 18, 14, 20, 45, 36, 28, 24, 30, 50, 39, 43, 64, 31, 22, 48, 42, 42, 68, 51, 16, 37, 22, 43, 55, 22, 26, 41, 40, 29, 27, 35, 29, 59, 42, 50, 59, 31, 29, 52, 55, 30, 26, 30, 30, 39, 32, 40, 19, 45, 30, 32, 12, 52, 37, 26, 45, 36, 60, 58, 15, 9, 38, 38, 36, 44, 47, 27, 38, 46, 36, 44, 26, 28, 24, 32, 44, 14, 31, 62, 60, 61, 12, 45, 38, 55, 27, 30, 30, 70, 48, 38, 49, 33, 46, 47, 39, 43, 22, 29, 31, 37, 69, 14, 45, 81, 38, 45, 32, 13, 41, 7, 38, 44, 54, 45, 35, 13, 35, 53, 55, 25, 9, 15, 36, 40, 26, 35, 25, 45, 15, 55, 47, 22, 50, 29, 41, 35, 46, 25, 33, 23, 20, 35, 34, 31, 32, 29, 42, 46, 19, 60, 57, 31, 29, 31, 36, 50, 59, 51, 33, 31, 61, 64, 28, 58, 48, 43, 24, 33, 40, 43, 21, 48, 37, 44, 14, 31, 28, 41, 33, 50, 52, 59, 54, 50, 23, 47, 27, 28, 54, 44, 34, 28, 60, 46, 37, 29, 28, 54, 14, 26, 19, 41, 46, 31, 20, 74, 27, 31, 38, 48, 24, 48, 57, 72, 11, 43]}}\n\n def read_dataset_from_file(filename):\n with open(filename, 'rb') as file:\n dataset = pickle.load(file)\n\n transformed_dataset = {}\n\n for num_items, instances in dataset.items():\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"] = {}\n for instance_num, items in enumerate(instances, 1):\n instance_name = f\"test_{instance_num-1}\"\n instance_data = {\n \"capacity\": 100,\n \"num_items\": num_items,\n \"items\": items\n }\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"][instance_name] = instance_data\n\n return transformed_dataset\n \n # self.datasets = read_dataset_from_file('../weibull_instances/test_dataset_100k.pkl')\n # for test_num in range(5):\n # test_key = f'test_{test_num}'\n # data = np.array(self.datasets['Weibull 5k'][test_key]['items'])\n # print(data)\n # print(self.datasets['Weibull 5k'][test_key]['capacity'])\n # data = data / self.datasets['Weibull 5k'][test_key]['capacity']\n # self.datasets['Weibull 5k'][test_key]['capacity'] = 1.0\n # top_500_items = data[:1000]\n # self.datasets['Weibull 5k'][test_key]['items'] = top_500_items\n # self.datasets['Weibull 5k'][test_key]['num_items'] = 1000\n\n\n\n def l1_bound(self,items: tuple, capacity: int) -> float:\n \"\"\"Computes L1 lower bound on OPT for bin packing.\n\n Args:\n items: Tuple of items to pack into bins.\n capacity: Capacity of bins.\n\n Returns:\n Lower bound on number of bins required to pack items.\n \"\"\"\n return np.ceil(np.sum(items) / capacity)\n\n\n def l1_bound_dataset(self,instances: dict) -> float:\n \"\"\"Computes the mean L1 lower bound across a dataset of bin packing instances.\n\n Args:\n instances: Dictionary containing a set of bin packing instances.\n\n Returns:\n Average L1 lower bound on number of bins required to pack items.\n \"\"\"\n l1_bounds = []\n for name in instances:\n instance = instances[name]\n l1_bounds.append(self.l1_bound(instance['items'], instance['capacity']))\n return np.mean(l1_bounds)\n\n def get_instances(self):\n opt_num_bins = {}\n for name, dataset in self.datasets.items():\n opt_num_bins[name] = self.l1_bound_dataset(dataset)\n print(opt_num_bins)\n return self.datasets, opt_num_bins\n\n\n" }, { "path": "eoh/src/eoh/problems/optimization/bp_online/prompts.py", "content": "class GetPrompts():\n def __init__(self):\n self.prompt_task = \"I need help designing a novel score function that scoring a set of bins to assign an item. \\\nIn each step, the item will be assigned to the bin with the maximum score. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\"\n self.prompt_func_name = \"score\"\n self.prompt_func_inputs = ['item', 'bins']\n self.prompt_func_outputs = ['scores']\n self.prompt_inout_inf = \"'item' and 'bins' are the size of current item and the rest capacities of feasible bins, which are larger than the item size. \\\nThe output named 'scores' is the scores for the bins for assignment. \"\n self.prompt_other_inf = \"Note that 'item' is of type int, while 'bins' and 'scores' are both Numpy arrays. The novel function should be sufficiently complex in order to achieve better performance. It is important to ensure self-consistency.\"\n#Include the following imports at the beginning of the code: 'import numpy as np', and 'from numba import jit'. Place '@jit(nopython=True)' just above the 'priority' function definition.\"\n\n def get_task(self):\n return self.prompt_task\n \n def get_func_name(self):\n return self.prompt_func_name\n \n def get_func_inputs(self):\n return self.prompt_func_inputs\n \n def get_func_outputs(self):\n return self.prompt_func_outputs\n \n def get_inout_inf(self):\n return self.prompt_inout_inf\n\n def get_other_inf(self):\n return self.prompt_other_inf\n\n" }, { "path": "eoh/src/eoh/problems/optimization/bp_online/run.py", "content": "import numpy as np\nimport importlib\nfrom .get_instance import GetData\nfrom .prompts import GetPrompts\nimport types\nimport warnings\nimport sys\n\nclass BPONLINE():\n def __init__(self):\n getdate = GetData()\n self.instances, self.lb = getdate.get_instances()\n self.prompts = GetPrompts()\n\n def get_valid_bin_indices(self,item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns indices of bins in which item can fit.\"\"\"\n return np.nonzero((bins - item) >= 0)[0]\n\n\n def online_binpack(self,items: tuple, bins: np.ndarray, alg):\n \"\"\"Performs online binpacking of `items` into `bins`.\"\"\"\n # Track which items are added to each bin.\n packing = [[] for _ in bins]\n # Add items to bins.\n n = 1\n for item in items:\n # Extract bins that have sufficient space to fit item.\n valid_bin_indices = self.get_valid_bin_indices(item, bins)\n # Score each bin based on heuristic.\n priorities = alg.score(item, bins[valid_bin_indices])\n # Add item to bin with highest priority.\n best_bin = valid_bin_indices[np.argmax(priorities)]\n bins[best_bin] -= item\n packing[best_bin].append(item)\n n=n+1\n \n # Remove unused bins from packing.\n packing = [bin_items for bin_items in packing if bin_items]\n return packing, bins\n\n\n # @funsearch.run\n def evaluateGreedy(self,alg) -> float:\n # algorithm_module = importlib.import_module(\"ael_alg\")\n # alg = importlib.reload(algorithm_module) \n \"\"\"Evaluate heuristic function on a set of online binpacking instances.\"\"\"\n # List storing number of bins used for each instance.\n #num_bins = []\n # Perform online binpacking for each instance.\n # for name in instances:\n # #print(name)\n\n for name, dataset in self.instances.items():\n num_bins_list = []\n for _, instance in dataset.items():\n\n capacity = instance['capacity']\n items = np.array(instance['items'])\n\n # items = items/capacity\n # capacity = 1.0\n\n # Create num_items bins so there will always be space for all items,\n # regardless of packing order. Array has shape (num_items,).\n bins = np.array([capacity for _ in range(instance['num_items'])])\n # Pack items into bins and return remaining capacity in bins_packed, which\n # has shape (num_items,).\n _, bins_packed = self.online_binpack(items, bins, alg)\n # If remaining capacity in a bin is equal to initial capacity, then it is\n # unused. Count number of used bins.\n num_bins = (bins_packed != capacity).sum()\n\n num_bins_list.append(-num_bins)\n\n # avg_num_bins = -self.evaluateGreedy(dataset, algorithm)\n avg_num_bins = -np.mean(np.array(num_bins_list))\n fitness = (avg_num_bins - self.lb[name]) / self.lb[name]\n\n\n # Score of heuristic function is negative of average number of bins used\n # across instances (as we want to minimize number of bins).\n\n return fitness\n\n\n\n # def evaluate(self):\n # try:\n\n # for name, dataset in self.instances.items():\n # # Parallelize the loop\n # num_bins = Parallel(n_jobs=4,timeout=30)(delayed(self.evaluateGreedy)(instance) for _, instance in dataset.items())\n # # avg_num_bins = -self.evaluateGreedy(dataset, algorithm)\n # avg_num_bins = -np.mean(num_bins)\n # excess = (avg_num_bins - self.lb[name]) / self.lb[name]\n # #print(name)\n # #print(f'\\t Average number of bins: {avg_num_bins}')\n # #print(f'\\t Lower bound on optimum: {self.lb[name]}')\n # #print(f'\\t Excess: {100 * excess:.2f}%') \n # return excess\n # except Exception as e:\n # #print(\"Error:\", str(e)) # Print the error message\n # return None\n \n def evaluate(self, code_string):\n try:\n # Suppress warnings\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n\n # Create a new module object\n heuristic_module = types.ModuleType(\"heuristic_module\")\n \n # Execute the code string in the new module's namespace\n exec(code_string, heuristic_module.__dict__)\n\n # Add the module to sys.modules so it can be imported\n sys.modules[heuristic_module.__name__] = heuristic_module\n\n fitness = self.evaluateGreedy(heuristic_module)\n\n return fitness\n except Exception as e:\n #print(\"Error:\", str(e))\n return None\n\n\n\n\n" }, { "path": "eoh/src/eoh/problems/optimization/tsp_greedy/__init__.py", "content": "" }, { "path": "eoh/src/eoh/problems/optimization/tsp_greedy/get_instance.py", "content": "\nimport numpy as np\nclass GetData():\n def __init__(self,n_instance,n_cities):\n self.n_instance = n_instance\n self.n_cities = n_cities\n\n def generate_instances(self):\n np.random.seed(2024)\n instance_data = []\n for _ in range(self.n_instance):\n coordinates = np.random.rand(self.n_cities, 2)\n distances = np.linalg.norm(coordinates[:, np.newaxis] - coordinates, axis=2)\n instance_data.append((coordinates,distances))\n return instance_data" }, { "path": "eoh/src/eoh/problems/optimization/tsp_greedy/prompts.py", "content": "\nclass GetPrompts():\n def __init__(self):\n self.prompt_task = \"Given a set of nodes with their coordinates, \\\nyou need to find the shortest route that visits each node once and returns to the starting node. \\\nThe task can be solved step-by-step by starting from the current node and iteratively choosing the next node. \\\nHelp me design a novel algorithm that is different from the algorithms in literature to select the next node in each step.\"\n self.prompt_func_name = \"select_next_node\"\n self.prompt_func_inputs = [\"current_node\",\"destination_node\",\"univisited_nodes\",\"distance_matrix\"]\n self.prompt_func_outputs = [\"next_node\"]\n self.prompt_inout_inf = \"'current_node', 'destination_node', 'next_node', and 'unvisited_nodes' are node IDs. 'distance_matrix' is the distance matrix of nodes.\"\n self.prompt_other_inf = \"All are Numpy arrays.\"\n\n def get_task(self):\n return self.prompt_task\n \n def get_func_name(self):\n return self.prompt_func_name\n \n def get_func_inputs(self):\n return self.prompt_func_inputs\n \n def get_func_outputs(self):\n return self.prompt_func_outputs\n \n def get_inout_inf(self):\n return self.prompt_inout_inf\n\n def get_other_inf(self):\n return self.prompt_other_inf\n\nif __name__ == \"__main__\":\n getprompts = GetPrompts()\n print(getprompts.get_task())\n" }, { "path": "eoh/src/eoh/problems/optimization/tsp_greedy/run.py", "content": "import numpy as np\nimport pickle\nimport sys\nimport types\nimport warnings\nfrom .prompts import GetPrompts\nfrom .get_instance import GetData\n\nclass TSPCONST():\n def __init__(self) -> None:\n # ABS_PATH = os.path.dirname(os.path.abspath(__file__))\n # sys.path.append(ABS_PATH) # This is for finding all the modules\n # Construct the absolute path to the pickle file\n #pickle_file_path = os.path.join(ABS_PATH, 'instances.pkl')\n\n # with open(\"./instances.pkl\" , 'rb') as f:\n # self.instance_data = pickle.load(f)\n self.ndelay = 1\n self.problem_size = 50\n self.neighbor_size = np.minimum(50,self.problem_size)\n self.n_instance = 8 \n self.running_time = 10\n\n\n\n self.prompts = GetPrompts()\n\n getData = GetData(self.n_instance,self.problem_size)\n self.instance_data = getData.generate_instances()\n \n\n def tour_cost(self,instance, solution, problem_size):\n cost = 0\n for j in range(problem_size - 1):\n cost += np.linalg.norm(instance[int(solution[j])] - instance[int(solution[j + 1])])\n cost += np.linalg.norm(instance[int(solution[-1])] - instance[int(solution[0])])\n return cost\n\n def generate_neighborhood_matrix(self,instance):\n instance = np.array(instance)\n n = len(instance)\n neighborhood_matrix = np.zeros((n, n), dtype=int)\n\n for i in range(n):\n distances = np.linalg.norm(instance[i] - instance, axis=1)\n sorted_indices = np.argsort(distances) # sort indices based on distances\n neighborhood_matrix[i] = sorted_indices\n\n return neighborhood_matrix\n\n\n #@func_set_timeout(5)\n def greedy(self,eva):\n\n dis = np.ones(self.n_instance)\n n_ins = 0\n for instance, distance_matrix in self.instance_data:\n\n # get neighborhood matrix\n neighbor_matrix = self.generate_neighborhood_matrix(instance)\n\n\n destination_node = 0\n\n current_node = 0\n\n route = np.zeros(self.problem_size)\n #print(\">>> Step 0 : select node \"+str(instance[0][0])+\", \"+str(instance[0][1]))\n for i in range(1,self.problem_size-1):\n\n near_nodes = neighbor_matrix[current_node][1:]\n\n mask = ~np.isin(near_nodes,route[:i])\n\n unvisited_near_nodes = near_nodes[mask]\n\n unvisited_near_size = np.minimum(self.neighbor_size,unvisited_near_nodes.size)\n\n unvisited_near_nodes = unvisited_near_nodes[:unvisited_near_size]\n\n next_node = eva.select_next_node(current_node, destination_node, unvisited_near_nodes, distance_matrix)\n\n if next_node in route:\n #print(\"wrong algorithm select duplicate node, retrying ...\")\n return None\n\n current_node = next_node\n\n route[i] = current_node\n\n #print(\">>> Step \"+str(i)+\": select node \"+str(instance[current_node][0])+\", \"+str(instance[current_node][1]))\n\n mask = ~np.isin(np.arange(self.problem_size),route[:self.problem_size-1])\n\n last_node = np.arange(self.problem_size)[mask]\n\n current_node = last_node[0]\n\n route[self.problem_size-1] = current_node\n\n #print(\">>> Step \"+str(self.problem_size-1)+\": select node \"+str(instance[current_node][0])+\", \"+str(instance[current_node][1]))\n\n LLM_dis = self.tour_cost(instance,route,self.problem_size)\n dis[n_ins] = LLM_dis\n\n n_ins += 1\n if n_ins == self.n_instance:\n break\n #self.route_plot(instance,route,self.oracle[n_ins])\n\n ave_dis = np.average(dis)\n #print(\"average dis: \",ave_dis)\n return ave_dis\n\n\n def evaluate(self, code_string):\n try:\n # Suppress warnings\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n # Create a new module object\n heuristic_module = types.ModuleType(\"heuristic_module\")\n \n # Execute the code string in the new module's namespace\n exec(code_string, heuristic_module.__dict__)\n\n # Add the module to sys.modules so it can be imported\n sys.modules[heuristic_module.__name__] = heuristic_module\n\n # Now you can use the module as you would any other\n fitness = self.greedy(heuristic_module)\n return fitness\n except Exception as e:\n #print(\"Error:\", str(e))\n return None\n # try:\n # heuristic_module = importlib.import_module(\"ael_alg\")\n # eva = importlib.reload(heuristic_module) \n # fitness = self.greedy(eva)\n # return fitness\n # except Exception as e:\n # print(\"Error:\",str(e))\n # return None\n \n\n\n" }, { "path": "eoh/src/eoh/problems/problems.py", "content": "# from machinelearning import *\n# from mathematics import *\n# from optimization import *\n# from physics import *\nclass Probs():\n def __init__(self,paras):\n\n if not isinstance(paras.problem, str):\n self.prob = paras.problem\n print(\"- Prob local loaded \")\n elif paras.problem == \"tsp_construct\":\n from .optimization.tsp_greedy import run\n self.prob = run.TSPCONST()\n print(\"- Prob \"+paras.problem+\" loaded \")\n elif paras.problem == \"bp_online\":\n from .optimization.bp_online import run\n self.prob = run.BPONLINE()\n print(\"- Prob \"+paras.problem+\" loaded \")\n else:\n print(\"problem \"+paras.problem+\" not found!\")\n\n\n def get_problem(self):\n\n return self.prob\n" }, { "path": "eoh/src/eoh/test/run.py", "content": "### Test Only ###\n# Set system path\nimport sys\nimport os\nABS_PATH = os.path.dirname(os.path.abspath(__file__))\nROOT_PATH = os.path.join(ABS_PATH, \"..\", \"..\")\nsys.path.append(ROOT_PATH) # This is for finding all the modules\nsys.path.append(ABS_PATH)\nprint(ABS_PATH)\nfrom eoh import eoh\nfrom eoh.utils.getParas import Paras\n# from evol.utils.createReport import ReportCreator\n# \n\n# Parameter initilization #\nparas = Paras() \n\n# Set parameters #\nparas.set_paras(method = \"eoh\", \n ec_operators = ['e1','e2','m1','m2','m3'], # operators in EoH\n problem = \"bp_online\", # ['tsp_construct','bp_online','tsp_gls','fssp_gls']\n llm_api_endpoint = \"XXX\", # set endpoint\n llm_api_key = \"XXX\", # set your key\n llm_model = \"XXX\", # set llm\n ec_pop_size = 4,\n ec_n_pop = 2,\n exp_n_proc = 4,\n exp_debug_mode = False)\n\n# EoH initilization\nevolution = eoh.EVOL(paras)\n\n# run EoH\nevolution.run()\n\n# Generate EoH Report\n# RC = ReportCreator(paras)\n# RC.generate_doc_report()\n\n\n\n\n" }, { "path": "eoh/src/eoh/utils/__init__.py", "content": "" }, { "path": "eoh/src/eoh/utils/createFolders.py", "content": "import os\nimport shutil\ndef create_folders(results_path):\n # Specify the path where you want to create the folder\n folder_path = os.path.join(results_path, \"results\")\n\n # Check if the folder already exists\n if not os.path.exists(folder_path):\n # Remove the existing folder and its contents\n #shutil.rmtree(folder_path)\n\n # Create the main folder \"results\"\n os.makedirs(folder_path)\n\n # Create subfolders inside \"results\"\n subfolders = [\"history\", \"pops\", \"pops_best\"]\n for subfolder in subfolders:\n subfolder_path = os.path.join(folder_path, subfolder)\n if not os.path.exists(subfolder_path):\n os.makedirs(subfolder_path)\n\n\n #print(\"Results folders created successfully!\")" }, { "path": "eoh/src/eoh/utils/createReport.py", "content": "from docx import Document\nfrom docx.shared import Inches\nimport numpy as np\nimport json\nimport matplotlib.pyplot as plt\nfrom docx.shared import RGBColor, Pt\nfrom docx.oxml import OxmlElement\nfrom docx.enum.table import WD_TABLE_ALIGNMENT\n\nclass ReportCreator():\n def __init__(self,paras) -> None:\n self.title = \"AEL Results\"\n self.exp_output_path = paras.exp_output_path\n self.ec_n_pop = paras.ec_n_pop\n self.ec_pop_size = paras.ec_pop_size\n self.paras = paras\n\n def create_convergence(self):\n n_start = 0\n obj_list = np.zeros((self.ec_n_pop,self.ec_pop_size))\n for i in range(n_start,n_start+self.ec_n_pop):\n ### Get result ###\n #Load JSON data from file\n with open(self.exp_output_path+\"ael_results/pops/population_generation_\"+str(i)+\".json\") as file:\n data = json.load(file)\n\n\n #Print each individual in the population\n na = 0\n for individual in data:\n code = individual['code']\n alg = individual['algorithm']\n obj = individual['objective']\n \n #code2file(alg,code,na,i)\n #print(obj)\n obj_list[i-n_start,na] = obj\n na +=1\n\n # Set font family to Times New Roman\n plt.rcParams['font.family'] = 'Times New Roman'\n # Generate x-axis values for number of generations\n generations = np.arange(1, obj_list.shape[0] + 1)\n best_objective = np.min(obj_list, axis=1)\n mean_objective = np.mean(obj_list, axis=1)\n\n # Set figure size\n plt.figure(figsize=(10, 6), dpi=80)\n\n # Plot objective value vs. number of generations for all samples as scatter points\n for i in generations:\n plt.scatter(i*np.ones(self.ec_pop_size), obj_list[i-1, :], color='tab:blue', alpha=0.6,s=200)\n\n # Plot mean and best objectives\n plt.plot(generations, mean_objective, label='Mean', color='orange',linewidth=3.0)\n plt.plot(generations, best_objective, label='Best', color='r',linewidth=3.0)\n\n # Set plot title and labels with enlarged font size\n plt.xlabel('Number of Generations', fontsize=18)\n plt.ylabel('Obj.', fontsize=20)\n\n objmin = np.min(obj_list)\n objmax = np.max(obj_list)\n delta=(objmax-objmin)/100.0\n # Set y-axis range\n plt.ylim([objmin-delta, objmax+delta])\n\n # Add scatter legend with enlarged font size\n plt.scatter([], [], color='tab:blue', alpha=0.6, label='Algorithms',s=200) # Empty scatter plot for legend\n #plt.legend(scatterpoints=1, frameon=False, labelspacing=1, fontsize=20)\n plt.legend(scatterpoints=1, frameon=True, labelspacing=1, fontsize=20, fancybox=True, facecolor='gainsboro')\n # Adjust ticks and grid\n plt.xticks(np.arange(1, obj_list.shape[0] + 1, 2),fontsize=18)\n plt.yticks(np.arange(objmin-delta, objmax+delta, 10),fontsize=18)\n plt.grid(True, which='both', linestyle='--', linewidth=0.5)\n\n # Show the plot\n plt.tight_layout()\n plt.savefig(self.exp_output_path+'ael_results/ael_convergence.png') # Save the plot as a file\n plt.savefig(self.exp_output_path+'ael_results/ael_convergence.pdf') \n #plt.show()\n \n def get_final_algorithms(self):\n ### Get result ###\n with open(self.exp_output_path+\"ael_results/pops/population_generation_\"+str(self.ec_n_pop)+\".json\") as file:\n data = json.load(file)\n\n # for individual in data:\n # #print(individual)\n # results = individual\n # code = results['code']\n # algorithm = results['algorithm']\n # gap = results['objective']\n \n # #code2file(code)\n \n # print(\"### algorithm: \\n\",algorithm)\n # print(\"### code: \\n\",code)\n # print(\"### Average gap is : \\n\",gap)\n # input() \n return data \n \n\n\n def generate_doc_report(self):\n # Create a new Document\n doc = Document()\n\n # Add Title\n doc.add_heading(self.title, level=1)\n\n # Add Parameter Settings\n doc.add_heading('Parameter Settings', level=2)\n table = doc.add_table(rows=1, cols=2)\n table.alignment = WD_TABLE_ALIGNMENT.CENTER\n\n # Set Table Style\n table.style = 'Table Grid'\n\n # Set Header Row\n hdr_cells = table.rows[0].cells\n hdr_cells[0].text = 'Parameter'\n hdr_cells[1].text = 'Value'\n for cell in hdr_cells:\n cell.paragraphs[0].runs[0].bold = True # Make headers bold\n\n # Add Data to Table\n for attr, value in vars(self.paras).items():\n row_cells = table.add_row().cells\n row_cells[0].text = attr\n row_cells[1].text = str(value)\n\n # Add Borderlines\n for row in table.rows:\n for cell in row.cells:\n for paragraph in cell.paragraphs:\n for run in paragraph.runs:\n run.font.size = Pt(10) # Set font size\n run.font.bold = False # Set font style\n run.font.name = 'Calibri' # Set font type\n run.font.color.rgb = RGBColor(0, 0, 0) # Set font color\n\n\n\n # Add Convergence Process\n doc.add_heading('Convergence Process', level=2)\n self.create_convergence()\n doc.add_picture(self.exp_output_path+'ael_results/ael_convergence.png', width=Inches(4))\n\n # Add Final Results\n doc.add_heading('Final Results', level=2)\n algorithms_data = self.get_final_algorithms()\n\n # Add top five algorithms data\n doc.add_heading('Top Five Algorithms', level=3)\n for i, algorithm_data in enumerate(algorithms_data[:5]):\n doc.add_heading(f'Algorithm {i+1}', level=4)\n doc.add_paragraph(f'Algorithm: {algorithm_data[\"algorithm\"]}')\n # Create a new paragraph\n p = doc.add_paragraph()\n\n # Add the code block with background color and border\n code = algorithm_data[\"code\"]\n code_block = p.add_run()\n code_block.text = f'Code:\\n{code}'\n code_block_font = code_block.font\n code_block_font.size = Pt(8)\n\n # Set the background color\n shading_elm = OxmlElement('w:shd')\n shading_elm.set('fill', 'D9D9D9') # Set your desired background color here\n p._element.append(shading_elm)\n\n # Set the border\n #p.border_top.space = Pt(1) # Set border space\n\n doc.add_paragraph(f'Fitness: {algorithm_data[\"objective\"]}')\n doc.add_paragraph('') # Add a blank paragraph for separation\n\n # Save the document\n doc.save('ael_report.docx')\n\n\n\nif __name__ == \"__main__\":\n\n Paras = Paras()\n\n RC = ReportCreator(Paras)\n\n RC.generate_doc_report()\n\n print(\"Doc report generated successfully!\")" }, { "path": "eoh/src/eoh/utils/getParas.py", "content": "\nclass Paras():\n def __init__(self):\n #####################\n ### General settings ###\n #####################\n self.method = 'eoh'\n self.problem = 'tsp_construct'\n self.selection = None\n self.management = None\n\n #####################\n ### EC settings ###\n #####################\n self.ec_pop_size = 5 # number of algorithms in each population, default = 10\n self.ec_n_pop = 5 # number of populations, default = 10\n self.ec_operators = None # evolution operators: ['e1','e2','m1','m2'], default = ['e1','e2','m1','m2']\n self.ec_m = 2 # number of parents for 'e1' and 'e2' operators, default = 2\n self.ec_operator_weights = None # weights for operators, i.e., the probability of use the operator in each iteration, default = [1,1,1,1]\n \n #####################\n ### LLM settings ###\n #####################\n self.llm_use_local = False # if use local model\n self.llm_local_url = None # your local server 'http://127.0.0.1:11012/completions'\n self.llm_api_endpoint = None # endpoint for remote LLM, e.g., api.deepseek.com\n self.llm_api_key = None # API key for remote LLM, e.g., sk-xxxx\n self.llm_model = None # model type for remote LLM, e.g., deepseek-chat\n\n #####################\n ### Exp settings ###\n #####################\n self.exp_debug_mode = False # if debug\n self.exp_output_path = \"./\" # default folder for ael outputs\n self.exp_use_seed = False\n self.exp_seed_path = \"./seeds/seeds.json\"\n self.exp_use_continue = False\n self.exp_continue_id = 0\n self.exp_continue_path = \"./results/pops/population_generation_0.json\"\n self.exp_n_proc = 1\n \n #####################\n ### Evaluation settings ###\n #####################\n self.eva_timeout = 30\n self.eva_numba_decorator = False\n\n\n def set_parallel(self):\n import multiprocessing\n num_processes = multiprocessing.cpu_count()\n if self.exp_n_proc == -1 or self.exp_n_proc > num_processes:\n self.exp_n_proc = num_processes\n print(f\"Set the number of proc to {num_processes} .\")\n \n def set_ec(self): \n \n if self.management == None:\n if self.method in ['ael','eoh']:\n self.management = 'pop_greedy'\n elif self.method == 'ls':\n self.management = 'ls_greedy'\n elif self.method == 'sa':\n self.management = 'ls_sa'\n \n if self.selection == None:\n self.selection = 'prob_rank'\n \n \n if self.ec_operators == None:\n if self.method == 'eoh':\n self.ec_operators = ['e1','e2','m1','m2']\n elif self.method == 'ael':\n self.ec_operators = ['crossover','mutation']\n elif self.method == 'ls':\n self.ec_operators = ['m1']\n elif self.method == 'sa':\n self.ec_operators = ['m1']\n\n if self.ec_operator_weights == None:\n self.ec_operator_weights = [1 for _ in range(len(self.ec_operators))]\n elif len(self.ec_operator) != len(self.ec_operator_weights):\n print(\"Warning! Lengths of ec_operator_weights and ec_operator shoud be the same.\")\n self.ec_operator_weights = [1 for _ in range(len(self.ec_operators))]\n \n if self.method in ['ls','sa'] and self.ec_pop_size >1:\n self.ec_pop_size = 1\n self.exp_n_proc = 1\n print(\"> single-point-based, set pop size to 1. \")\n \n def set_evaluation(self):\n # Initialize evaluation settings\n if self.problem == 'bp_online':\n self.eva_timeout = 40\n elif self.problem == 'tsp_construct':\n self.eva_timeout = 40\n \n def set_paras(self, *args, **kwargs):\n \n # Map paras\n for key, value in kwargs.items():\n if hasattr(self, key):\n setattr(self, key, value)\n \n # Identify and set parallel \n self.set_parallel()\n \n # Initialize method and ec settings\n self.set_ec()\n \n # Initialize evaluation settings\n self.set_evaluation()\n\n\n\n\nif __name__ == \"__main__\":\n\n # Create an instance of the Paras class\n paras_instance = Paras()\n\n # Setting parameters using the set_paras method\n paras_instance.set_paras(llm_use_local=True, llm_local_url='http://example.com', ec_pop_size=8)\n\n # Accessing the updated parameters\n print(paras_instance.llm_use_local) # Output: True\n print(paras_instance.llm_local_url) # Output: http://example.com\n print(paras_instance.ec_pop_size) # Output: 8\n \n \n \n" }, { "path": "eoh/src/eoh/utils/get_algorithm&code_pop.py", "content": "import json\n\n### Get result ###\n#Load JSON data from file\nwith open(\"./population_generation_9.json\") as file:\n data = json.load(file)\n\n\n#Print each individual in the population\n\nfor individual in data:\n #print(individual)\n results = individual\n code = results['code']\n algorithm = results['algorithm']\n gap = results['objective']\n \n #code2file(code)\n \n print(\"### algorithm: \\n\",algorithm)\n print(\"### code: \\n\",code)\n print(\"### Average gap is : \\n\",gap)\n input()\n\n" }, { "path": "eoh/src/eoh/utils/get_all_results.py", "content": "import json\nimport numpy as np\n\nng = 10\nn = 10\nn_start = 0\n\ndef code2file(algorithm,code,n,ng):\n with open(\"algorithm_\"+str(ng)+\"_\"+str(n)+\".txt\", \"w\") as file:\n # Write the code to the file\n file.write(algorithm)\n file.write(code) \n return\n\nobj_list = np.zeros((ng,n))\nfor i in range(n_start,n_start+ng):\n ### Get result ###\n #Load JSON data from file\n with open(\"population_generation_\"+str(i)+\".json\") as file:\n data = json.load(file)\n\n\n #Print each individual in the population\n na = 0\n for individual in data:\n code = individual['code']\n alg = individual['algorithm']\n obj = individual['objective']\n \n #code2file(alg,code,na,i)\n #print(obj)\n obj_list[i-n_start,na] = obj\n na +=1\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Set font family to Times New Roman\nplt.rcParams['font.family'] = 'Times New Roman'\n# Generate x-axis values for number of generations\ngenerations = np.arange(1, obj_list.shape[0] + 1)\nbest_objective = np.min(obj_list, axis=1)\nmean_objective = np.mean(obj_list, axis=1)\n\n# Set figure size\nplt.figure(figsize=(10, 6), dpi=80)\n\n# Plot objective value vs. number of generations for all samples as scatter points\nfor i in generations:\n plt.scatter(i*np.ones(n), obj_list[i-1, :], color='tab:blue', alpha=0.6,s=200)\n \n\n#plt.plot(generations, 0.663*np.ones_like(generations), color='k', linestyle=':', label='Human-GLS',linewidth=3.0)\n\n#plt.plot(generations, 0.175*np.ones_like(generations), color='purple', linestyle='--', label='Human-EBGLS',linewidth=3.0)\n\n#plt.plot(generations, 0.035*np.ones_like(generations), color='orange', linestyle='-.', label='Human-KGLS',linewidth=3.0)\n\n# Plot mean and best objectives\n#plt.plot(generations, mean_objective, label='Mean', color='orange')\nplt.plot(generations, best_objective, label='AEL-GLS', color='r',linewidth=3.0)\n\n# Set plot title and labels with enlarged font size\n#plt.title('Objective Value vs. Number of Generations', fontsize=18)\nplt.xlabel('Number of Generations', fontsize=18)\nplt.ylabel('Average Makespan', fontsize=20)\n\n# Set y-axis range\nplt.ylim([3150, 3200])\n\n# Add legend with enlarged font size\n#plt.legend(fontsize=18)\n\n\n\n# Add scatter legend with enlarged font size\nplt.scatter([], [], color='tab:blue', alpha=0.6, label='Algorithms',s=200) # Empty scatter plot for legend\n#plt.legend(scatterpoints=1, frameon=False, labelspacing=1, fontsize=20)\nplt.legend(scatterpoints=1, frameon=True, labelspacing=1, fontsize=20, fancybox=True, facecolor='gainsboro')\n# Adjust ticks and grid\nplt.xticks(np.arange(1, obj_list.shape[0] + 1, 2),fontsize=18)\nplt.yticks(np.arange(3150, 3200, 10),fontsize=18)\nplt.grid(True, which='both', linestyle='--', linewidth=0.5)\n\n# Show the plot\nplt.tight_layout()\nplt.savefig('plot.png') # Save the plot as a file\nplt.savefig('plot.pdf') \nplt.show()\n" }, { "path": "examples/bp_online/evaluation/evaluation.py", "content": "import numpy as np\n\n\nclass Evaluation():\n def __init__(self):\n \n self.instances, self.lb = None, None\n\n\n def get_valid_bin_indices(self,item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns indices of bins in which item can fit.\"\"\"\n return np.nonzero((bins - item) >= 0)[0]\n\n\n def online_binpack(self,items: tuple, bins: np.ndarray, alg):\n \"\"\"Performs online binpacking of `items` into `bins`.\"\"\"\n # Track which items are added to each bin.\n packing = [[] for _ in bins]\n # Add items to bins.\n for item in items:\n # Extract bins that have sufficient space to fit item.\n valid_bin_indices = self.get_valid_bin_indices(item, bins)\n # Score each bin based on heuristic.\n priorities = alg.score(item, bins[valid_bin_indices])\n # Add item to bin with highest priority.\n #print(priorities)\n best_bin = valid_bin_indices[np.argmax(priorities)]\n bins[best_bin] -= item\n packing[best_bin].append(item)\n # Remove unused bins from packing.\n packing = [bin_items for bin_items in packing if bin_items]\n return packing, bins\n\n\n # @funsearch.run\n def evaluateGreedy(self,instances: dict,alg) -> float:\n\n \"\"\"Evaluate heuristic function on a set of online binpacking instances.\"\"\"\n # List storing number of bins used for each instance.\n num_bins = []\n # Perform online binpacking for each instance.\n #print(len(instances))\n for name in instances:\n #print(name)\n instance = instances[name]\n capacity = instance['capacity']\n items = np.array(instance['items'])\n\n # items = items/capacity\n # capacity = 1.0\n\n # Create num_items bins so there will always be space for all items,\n # regardless of packing order. Array has shape (num_items,).\n bins = np.array([capacity for _ in range(instance['num_items'])])\n # Pack items into bins and return remaining capacity in bins_packed, which\n # has shape (num_items,).\n _, bins_packed = self.online_binpack(items, bins, alg)\n # If remaining capacity in a bin is equal to initial capacity, then it is\n # unused. Count number of used bins.\n num_bins.append((bins_packed != capacity).sum())\n # Score of heuristic function is negative of average number of bins used\n # across instances (as we want to minimize number of bins).\n return -np.mean(num_bins)\n\n\n\n\n\n" }, { "path": "examples/bp_online/evaluation/get_instance.py", "content": "import numpy as np\nimport pickle\nclass GetData():\n def __init__(self) -> None:\n self.datasets = {}\n # Data from the Weibull 5k test dataset, containing 5 bin packing instances\n # each with 5,000 items.\n self.datasets['Weibull 5k'] = {'test_0': {'capacity': 1000, 'num_items': 5000, 'items': [48, 66, 48, 32, 72, 37, 41, 21, 58, 35, 18, 53, 52, 42, 51, 30, 42, 44, 58, 62, 28, 20, 27, 53, 59, 56, 46, 60, 21, 49, 29, 58, 31, 47, 34, 41, 28, 49, 22, 37, 31, 27, 50, 46, 39, 52, 40, 41, 31, 57, 53, 57, 35, 39, 38, 40, 34, 22, 30, 48, 34, 34, 48, 53, 23, 57, 50, 67, 18, 40, 38, 38, 42, 53, 38, 37, 53, 62, 22, 51, 34, 51, 24, 92, 60, 29, 39, 49, 24, 33, 67, 65, 62, 57, 60, 29, 53, 29, 54, 52, 37, 59, 55, 69, 20, 41, 47, 44, 36, 48, 61, 33, 53, 36, 47, 38, 39, 35, 41, 31, 42, 41, 45, 49, 25, 20, 71, 61, 35, 33, 42, 11, 39, 68, 43, 30, 51, 31, 68, 29, 40, 45, 41, 23, 46, 65, 37, 60, 45, 38, 28, 45, 42, 30, 39, 59, 36, 60, 58, 32, 49, 19, 55, 46, 55, 53, 46, 32, 56, 29, 23, 22, 26, 19, 37, 24, 50, 44, 33, 27, 26, 34, 38, 21, 58, 48, 66, 37, 40, 10, 37, 27, 56, 30, 49, 19, 52, 17, 41, 29, 38, 53, 21, 36, 37, 23, 35, 26, 25, 33, 11, 34, 18, 69, 36, 50, 40, 19, 65, 51, 53, 35, 35, 45, 21, 27, 60, 35, 56, 14, 65, 40, 24, 39, 49, 85, 54, 32, 28, 27, 9, 28, 44, 47, 65, 59, 23, 46, 36, 46, 18, 20, 20, 36, 50, 71, 57, 63, 31, 35, 47, 35, 35, 41, 48, 19, 53, 69, 26, 43, 45, 27, 52, 19, 49, 45, 29, 32, 29, 22, 52, 15, 47, 39, 26, 41, 27, 31, 63, 50, 21, 30, 21, 42, 43, 21, 71, 21, 34, 29, 80, 41, 37, 51, 35, 33, 45, 26, 44, 30, 41, 22, 55, 26, 43, 35, 15, 31, 32, 53, 36, 33, 25, 19, 29, 64, 56, 17, 30, 13, 66, 19, 39, 51, 38, 39, 54, 37, 37, 17, 8, 45, 58, 19, 48, 51, 41, 53, 69, 33, 37, 29, 25, 41, 54, 51, 26, 29, 66, 60, 36, 33, 17, 31, 48, 73, 16, 26, 46, 25, 25, 33, 57, 49, 28, 62, 44, 22, 19, 65, 25, 60, 39, 39, 36, 45, 40, 45, 43, 28, 45, 28, 54, 44, 54, 32, 62, 67, 34, 31, 29, 47, 38, 35, 69, 57, 40, 20, 37, 27, 56, 25, 57, 54, 36, 45, 56, 49, 35, 77, 71, 53, 46, 41, 25, 50, 50, 44, 79, 52, 19, 44, 43, 36, 40, 36, 36, 35, 51, 35, 41, 67, 47, 46, 13, 53, 56, 37, 41, 46, 36, 70, 29, 18, 35, 59, 7, 51, 36, 52, 24, 40, 21, 74, 21, 23, 28, 47, 43, 40, 50, 61, 65, 17, 59, 60, 52, 53, 19, 51, 63, 59, 25, 42, 50, 50, 60, 61, 27, 37, 25, 55, 69, 45, 51, 36, 47, 20, 56, 39, 20, 43, 50, 34, 42, 37, 60, 48, 18, 41, 42, 35, 34, 46, 20, 61, 57, 25, 42, 72, 16, 39, 29, 64, 37, 44, 39, 32, 47, 61, 23, 41, 21, 38, 33, 67, 60, 54, 66, 51, 70, 39, 34, 47, 16, 38, 48, 54, 15, 34, 34, 14, 22, 25, 32, 11, 19, 44, 32, 36, 43, 20, 55, 46, 38, 62, 43, 35, 19, 47, 31, 17, 42, 31, 39, 49, 37, 53, 36, 64, 29, 19, 42, 47, 45, 9, 45, 52, 59, 35, 67, 25, 27, 55, 44, 47, 38, 17, 24, 61, 68, 35, 36, 18, 23, 50, 20, 36, 35, 48, 32, 29, 62, 23, 32, 36, 25, 15, 57, 50, 43, 43, 30, 24, 56, 52, 65, 17, 48, 29, 64, 52, 20, 45, 60, 54, 38, 57, 27, 32, 20, 44, 18, 18, 32, 38, 36, 39, 17, 41, 42, 67, 39, 21, 30, 61, 40, 43, 31, 16, 40, 41, 38, 38, 11, 43, 40, 17, 41, 65, 48, 42, 47, 24, 86, 26, 29, 48, 34, 19, 55, 65, 53, 68, 43, 41, 28, 50, 49, 15, 42, 26, 14, 45, 26, 61, 54, 25, 44, 28, 43, 43, 18, 44, 21, 52, 47, 38, 32, 55, 54, 24, 75, 38, 53, 24, 24, 39, 63, 32, 47, 32, 67, 32, 43, 25, 52, 47, 48, 50, 56, 18, 48, 64, 66, 37, 36, 42, 30, 37, 53, 32, 73, 40, 55, 30, 38, 34, 60, 39, 22, 43, 32, 13, 44, 41, 23, 48, 28, 42, 22, 34, 49, 55, 27, 34, 38, 43, 35, 71, 61, 44, 32, 22, 27, 82, 38, 50, 30, 54, 29, 48, 45, 45, 42, 64, 36, 44, 26, 52, 12, 32, 46, 50, 23, 56, 54, 23, 47, 46, 38, 60, 45, 38, 58, 48, 53, 37, 34, 45, 25, 38, 32, 11, 46, 38, 32, 42, 58, 59, 12, 50, 49, 44, 46, 37, 53, 58, 47, 34, 45, 39, 58, 31, 29, 36, 38, 36, 49, 56, 45, 34, 28, 7, 31, 42, 15, 49, 51, 47, 26, 20, 52, 26, 50, 32, 34, 33, 51, 73, 17, 45, 40, 35, 24, 30, 46, 42, 21, 11, 49, 32, 67, 50, 47, 54, 44, 57, 55, 36, 51, 37, 26, 35, 20, 42, 32, 46, 30, 33, 44, 67, 23, 47, 45, 39, 14, 37, 41, 29, 59, 53, 21, 15, 49, 37, 56, 19, 28, 48, 41, 30, 27, 32, 10, 83, 58, 22, 40, 46, 52, 34, 34, 43, 22, 17, 28, 67, 58, 35, 33, 18, 11, 44, 35, 20, 60, 50, 44, 23, 49, 29, 44, 66, 37, 44, 15, 62, 27, 41, 52, 32, 44, 28, 11, 32, 28, 72, 35, 21, 54, 42, 57, 37, 26, 37, 43, 49, 24, 57, 37, 37, 41, 19, 27, 40, 49, 50, 14, 59, 61, 34, 35, 53, 33, 36, 31, 42, 32, 60, 20, 46, 41, 31, 12, 59, 22, 60, 53, 22, 58, 19, 27, 23, 37, 32, 42, 58, 24, 38, 29, 26, 57, 17, 34, 34, 17, 35, 61, 48, 45, 31, 38, 22, 47, 38, 25, 47, 47, 43, 38, 46, 52, 45, 39, 64, 21, 35, 31, 32, 44, 46, 31, 75, 48, 23, 47, 31, 34, 22, 24, 50, 28, 32, 23, 49, 53, 51, 30, 70, 36, 28, 54, 14, 61, 61, 37, 24, 38, 34, 43, 26, 38, 44, 55, 42, 33, 35, 29, 28, 18, 19, 51, 39, 28, 54, 43, 43, 41, 27, 29, 17, 14, 44, 46, 77, 55, 34, 61, 45, 29, 24, 32, 38, 15, 72, 9, 19, 25, 59, 21, 53, 13, 42, 38, 29, 30, 39, 59, 41, 13, 38, 46, 21, 49, 41, 28, 19, 61, 24, 15, 52, 34, 23, 55, 31, 36, 54, 45, 66, 69, 37, 54, 69, 50, 62, 15, 49, 29, 56, 25, 64, 30, 34, 25, 23, 46, 52, 59, 40, 58, 59, 58, 57, 21, 25, 44, 28, 41, 44, 13, 17, 81, 29, 68, 61, 42, 38, 66, 10, 57, 49, 63, 31, 67, 63, 20, 65, 35, 14, 73, 55, 37, 69, 46, 48, 24, 39, 42, 45, 27, 48, 43, 24, 30, 41, 24, 43, 49, 45, 61, 56, 43, 39, 59, 61, 36, 22, 54, 38, 73, 44, 26, 49, 50, 44, 44, 30, 26, 16, 46, 29, 25, 54, 26, 52, 63, 61, 23, 23, 44, 31, 48, 27, 32, 28, 33, 46, 41, 35, 29, 56, 62, 81, 58, 67, 7, 46, 79, 36, 18, 37, 48, 34, 48, 56, 38, 18, 27, 33, 53, 21, 37, 43, 31, 50, 27, 39, 25, 41, 58, 24, 46, 43, 62, 28, 51, 20, 65, 57, 70, 15, 31, 73, 13, 32, 64, 32, 17, 60, 37, 35, 27, 49, 38, 42, 37, 49, 26, 51, 66, 19, 20, 63, 44, 21, 40, 44, 65, 44, 50, 51, 26, 45, 53, 46, 35, 65, 26, 62, 37, 24, 64, 13, 60, 54, 46, 37, 31, 48, 29, 18, 31, 12, 45, 31, 29, 31, 32, 35, 40, 40, 26, 41, 55, 21, 14, 47, 54, 41, 64, 13, 17, 68, 28, 11, 47, 65, 35, 25, 56, 68, 48, 25, 67, 43, 38, 10, 56, 31, 69, 42, 61, 45, 40, 54, 34, 32, 48, 65, 52, 58, 40, 28, 21, 20, 53, 41, 28, 45, 25, 69, 47, 38, 62, 30, 47, 16, 35, 61, 29, 29, 32, 76, 51, 50, 38, 58, 33, 48, 48, 48, 19, 22, 66, 42, 53, 35, 17, 30, 27, 45, 24, 52, 14, 32, 63, 44, 34, 31, 72, 28, 43, 17, 40, 58, 54, 25, 38, 41, 46, 22, 34, 26, 56, 31, 29, 19, 56, 46, 38, 57, 40, 30, 46, 36, 61, 34, 39, 52, 49, 8, 56, 49, 21, 30, 23, 34, 43, 50, 49, 70, 53, 19, 47, 48, 47, 22, 22, 49, 33, 53, 28, 39, 55, 32, 41, 31, 24, 30, 32, 42, 33, 31, 54, 38, 22, 63, 42, 29, 54, 50, 56, 39, 49, 38, 40, 33, 42, 61, 59, 22, 26, 41, 19, 71, 54, 46, 31, 47, 45, 21, 53, 40, 31, 67, 45, 66, 37, 21, 38, 45, 34, 41, 41, 45, 32, 46, 66, 60, 43, 41, 31, 56, 64, 39, 65, 19, 70, 38, 66, 28, 35, 26, 35, 20, 60, 31, 52, 30, 28, 26, 34, 50, 50, 57, 33, 48, 18, 28, 20, 68, 43, 41, 19, 36, 58, 56, 27, 48, 14, 45, 52, 31, 65, 40, 31, 19, 58, 43, 67, 16, 55, 60, 25, 43, 44, 29, 76, 50, 32, 55, 21, 37, 51, 64, 60, 41, 22, 31, 37, 30, 60, 33, 57, 40, 32, 10, 36, 33, 75, 47, 18, 64, 50, 32, 29, 41, 17, 38, 64, 58, 57, 44, 29, 50, 21, 66, 42, 40, 20, 39, 25, 44, 42, 18, 57, 46, 29, 42, 11, 17, 49, 38, 22, 3, 43, 34, 38, 21, 65, 44, 24, 28, 58, 51, 73, 34, 35, 36, 64, 59, 54, 16, 22, 39, 35, 18, 40, 50, 29, 43, 41, 11, 27, 49, 86, 49, 27, 44, 28, 19, 31, 31, 78, 23, 25, 44, 17, 34, 36, 22, 39, 6, 31, 41, 34, 37, 35, 36, 62, 65, 18, 25, 42, 39, 61, 41, 61, 55, 58, 32, 56, 44, 37, 35, 39, 41, 39, 58, 59, 45, 42, 50, 46, 76, 62, 27, 50, 50, 66, 30, 59, 34, 9, 32, 12, 30, 47, 32, 30, 48, 41, 33, 71, 39, 47, 49, 20, 28, 67, 29, 35, 28, 17, 45, 72, 48, 26, 52, 26, 71, 34, 60, 27, 64, 20, 54, 34, 57, 38, 68, 38, 45, 54, 21, 39, 41, 13, 39, 31, 22, 53, 44, 52, 18, 41, 22, 34, 30, 29, 12, 38, 62, 51, 61, 11, 35, 46, 33, 49, 9, 38, 50, 35, 38, 52, 42, 68, 48, 69, 50, 56, 40, 55, 34, 66, 25, 34, 25, 28, 53, 51, 40, 51, 77, 26, 29, 42, 36, 44, 43, 39, 62, 54, 42, 34, 7, 59, 65, 21, 39, 51, 57, 25, 28, 47, 37, 33, 66, 47, 31, 52, 46, 25, 51, 41, 41, 24, 47, 41, 47, 42, 65, 56, 40, 39, 68, 9, 50, 53, 27, 59, 49, 38, 38, 52, 29, 15, 46, 40, 47, 40, 45, 21, 36, 31, 27, 35, 48, 50, 54, 21, 32, 47, 29, 24, 35, 37, 38, 40, 51, 52, 56, 29, 17, 40, 51, 41, 28, 16, 55, 38, 25, 43, 43, 58, 55, 63, 46, 24, 26, 35, 48, 56, 20, 48, 54, 43, 24, 48, 29, 43, 24, 1, 44, 45, 27, 62, 41, 30, 32, 69, 39, 45, 45, 42, 22, 43, 25, 7, 32, 38, 49, 42, 50, 53, 61, 45, 53, 52, 50, 40, 56, 31, 47, 27, 46, 51, 18, 35, 23, 25, 35, 37, 49, 38, 44, 36, 35, 54, 28, 59, 48, 34, 42, 57, 39, 44, 49, 42, 47, 40, 37, 35, 59, 3, 55, 43, 32, 60, 17, 15, 39, 34, 28, 52, 21, 39, 32, 61, 50, 57, 46, 58, 52, 49, 43, 34, 30, 25, 69, 58, 28, 34, 40, 25, 40, 25, 42, 42, 35, 42, 30, 33, 19, 38, 49, 65, 45, 57, 6, 32, 45, 48, 73, 26, 47, 28, 66, 36, 38, 44, 53, 29, 48, 40, 59, 47, 53, 43, 39, 55, 59, 42, 33, 45, 47, 30, 30, 30, 40, 57, 63, 48, 50, 69, 56, 40, 37, 31, 55, 75, 47, 18, 34, 35, 46, 19, 20, 25, 47, 13, 32, 57, 40, 24, 38, 16, 46, 9, 24, 44, 51, 46, 25, 54, 17, 33, 41, 21, 50, 45, 48, 33, 32, 35, 33, 43, 18, 56, 61, 83, 48, 21, 36, 73, 34, 32, 38, 19, 55, 37, 62, 61, 47, 74, 47, 41, 31, 47, 52, 81, 54, 42, 47, 45, 61, 25, 36, 57, 27, 42, 61, 35, 52, 87, 61, 21, 20, 28, 50, 20, 23, 57, 67, 64, 17, 38, 42, 18, 47, 34, 64, 22, 41, 44, 38, 19, 12, 31, 36, 45, 49, 54, 40, 29, 26, 33, 39, 36, 43, 32, 34, 32, 13, 37, 45, 67, 36, 43, 53, 19, 53, 33, 29, 36, 47, 45, 47, 21, 34, 23, 43, 26, 16, 35, 48, 31, 47, 53, 34, 31, 65, 50, 47, 18, 8, 38, 48, 40, 27, 46, 55, 22, 23, 62, 29, 50, 20, 64, 51, 46, 49, 40, 27, 47, 31, 33, 28, 42, 52, 41, 33, 25, 33, 27, 23, 52, 43, 47, 7, 14, 41, 50, 33, 38, 20, 49, 39, 55, 47, 43, 22, 24, 63, 29, 65, 24, 27, 21, 57, 34, 42, 29, 28, 74, 31, 25, 45, 26, 10, 45, 5, 35, 15, 33, 18, 27, 58, 51, 48, 18, 56, 34, 44, 48, 36, 49, 87, 48, 57, 35, 23, 51, 24, 33, 34, 39, 42, 20, 37, 47, 52, 31, 27, 12, 41, 37, 80, 33, 61, 79, 71, 47, 70, 60, 60, 29, 42, 50, 27, 32, 57, 41, 27, 31, 62, 37, 30, 53, 46, 40, 33, 62, 39, 31, 74, 25, 55, 36, 71, 59, 28, 8, 28, 23, 53, 13, 31, 10, 56, 50, 43, 22, 53, 63, 33, 34, 50, 30, 34, 38, 36, 29, 31, 22, 42, 74, 37, 50, 39, 42, 29, 62, 38, 16, 58, 18, 49, 58, 50, 23, 36, 36, 53, 47, 57, 77, 45, 44, 11, 32, 22, 48, 49, 25, 61, 59, 69, 21, 44, 69, 45, 41, 22, 44, 40, 53, 43, 27, 46, 21, 47, 26, 24, 35, 38, 46, 59, 66, 48, 45, 42, 36, 47, 45, 18, 49, 5, 27, 33, 58, 78, 16, 23, 19, 34, 16, 46, 48, 36, 28, 56, 49, 53, 43, 27, 42, 41, 39, 23, 24, 20, 30, 12, 68, 30, 59, 29, 17, 29, 39, 51, 47, 59, 50, 52, 23, 18, 78, 67, 16, 50, 49, 19, 55, 31, 47, 50, 66, 45, 35, 33, 39, 42, 42, 49, 42, 62, 46, 56, 31, 43, 36, 38, 34, 61, 50, 55, 42, 34, 31, 38, 21, 52, 33, 65, 46, 26, 55, 35, 19, 60, 69, 47, 24, 22, 45, 40, 43, 66, 49, 32, 21, 15, 51, 50, 20, 69, 15, 36, 31, 49, 18, 41, 21, 48, 18, 47, 11, 46, 45, 19, 60, 53, 28, 15, 24, 47, 49, 40, 40, 65, 56, 54, 61, 61, 25, 39, 61, 30, 47, 49, 31, 27, 23, 51, 37, 47, 46, 36, 19, 45, 22, 46, 31, 48, 8, 44, 20, 15, 12, 52, 30, 24, 40, 19, 54, 70, 58, 55, 25, 48, 49, 49, 23, 60, 23, 44, 39, 28, 57, 55, 58, 44, 27, 36, 53, 32, 18, 36, 58, 41, 25, 43, 46, 18, 40, 35, 55, 46, 37, 23, 16, 56, 26, 32, 34, 61, 68, 48, 43, 35, 40, 51, 30, 22, 41, 25, 43, 63, 44, 50, 27, 38, 32, 30, 20, 46, 63, 6, 50, 32, 47, 59, 29, 48, 30, 72, 19, 41, 34, 21, 24, 29, 43, 46, 36, 68, 37, 41, 66, 52, 19, 50, 36, 26, 26, 41, 19, 48, 71, 37, 72, 22, 42, 54, 33, 20, 63, 56, 30, 44, 44, 49, 60, 45, 63, 14, 44, 40, 66, 36, 22, 46, 13, 42, 27, 9, 63, 48, 73, 38, 32, 9, 28, 60, 53, 50, 39, 36, 51, 37, 59, 49, 53, 37, 44, 48, 42, 29, 65, 37, 54, 35, 22, 10, 40, 36, 35, 25, 43, 59, 4, 33, 18, 23, 50, 33, 60, 48, 27, 18, 47, 55, 51, 63, 45, 56, 50, 57, 44, 22, 55, 34, 48, 43, 39, 27, 41, 31, 33, 21, 27, 34, 29, 37, 27, 48, 44, 55, 55, 33, 51, 52, 70, 51, 29, 71, 42, 51, 49, 27, 35, 36, 38, 43, 38, 59, 50, 52, 33, 54, 62, 28, 41, 23, 44, 25, 21, 61, 54, 35, 19, 54, 31, 38, 21, 50, 46, 26, 47, 46, 32, 48, 48, 39, 37, 24, 33, 19, 51, 34, 51, 27, 56, 35, 34, 33, 57, 33, 10, 48, 30, 49, 61, 37, 70, 40, 35, 35, 30, 27, 52, 38, 52, 57, 36, 43, 15, 27, 50, 55, 14, 37, 40, 71, 69, 26, 43, 31, 47, 43, 41, 44, 24, 17, 29, 64, 26, 27, 82, 17, 35, 53, 16, 22, 20, 34, 52, 32, 50, 51, 17, 28, 34, 42, 58, 23, 28, 30, 69, 37, 57, 52, 41, 29, 40, 58, 63, 66, 24, 39, 88, 44, 50, 31, 15, 51, 68, 24, 34, 34, 37, 51, 27, 64, 34, 50, 40, 43, 42, 47, 39, 30, 23, 23, 23, 51, 39, 27, 46, 64, 49, 50, 15, 15, 31, 29, 33, 50, 52, 24, 45, 41, 52, 61, 30, 40, 34, 51, 46, 36, 17, 50, 27, 47, 52, 54, 23, 64, 48, 40, 57, 11, 49, 29, 23, 62, 43, 66, 24, 16, 57, 10, 16, 20, 57, 23, 52, 34, 46, 29, 57, 48, 37, 45, 13, 47, 41, 42, 45, 65, 18, 50, 43, 40, 52, 49, 52, 29, 43, 37, 57, 79, 45, 51, 68, 33, 36, 30, 42, 37, 66, 40, 42, 44, 34, 59, 36, 34, 26, 44, 32, 36, 53, 44, 50, 24, 32, 13, 33, 23, 33, 35, 32, 49, 38, 54, 17, 39, 20, 45, 77, 53, 69, 22, 56, 50, 10, 44, 38, 56, 62, 35, 47, 65, 37, 58, 38, 31, 57, 22, 46, 19, 21, 55, 53, 39, 29, 45, 26, 49, 40, 41, 34, 36, 10, 51, 49, 40, 34, 16, 51, 26, 51, 24, 36, 42, 45, 56, 30, 36, 42, 22, 27, 32, 45, 50, 43, 61, 33, 56, 38, 38, 48, 37, 31, 14, 37, 17, 13, 37, 55, 13, 56, 34, 43, 33, 23, 29, 48, 51, 32, 18, 41, 32, 37, 53, 36, 49, 22, 38, 40, 28, 62, 43, 42, 40, 31, 36, 58, 29, 44, 35, 46, 37, 42, 43, 39, 53, 37, 35, 31, 42, 20, 24, 52, 37, 42, 66, 43, 12, 61, 17, 46, 34, 14, 45, 22, 22, 44, 15, 29, 51, 43, 50, 31, 30, 42, 45, 39, 55, 35, 50, 45, 66, 43, 54, 47, 45, 30, 37, 39, 24, 26, 34, 47, 42, 38, 64, 32, 28, 32, 33, 32, 36, 36, 27, 23, 62, 29, 62, 48, 39, 27, 58, 33, 35, 58, 50, 29, 24, 34, 69, 28, 19, 29, 26, 28, 28, 46, 79, 40, 61, 81, 66, 63, 68, 47, 24, 52, 17, 40, 22, 19, 20, 20, 44, 33, 66, 39, 32, 45, 17, 14, 44, 45, 34, 47, 58, 40, 64, 35, 31, 31, 39, 28, 38, 48, 43, 23, 22, 35, 45, 37, 41, 40, 20, 22, 33, 11, 45, 44, 58, 35, 48, 38, 53, 50, 27, 34, 23, 40, 39, 55, 70, 40, 17, 51, 28, 22, 34, 24, 21, 61, 50, 44, 64, 26, 58, 23, 63, 57, 40, 25, 27, 21, 37, 37, 46, 36, 41, 35, 73, 33, 26, 15, 14, 8, 43, 57, 29, 38, 49, 22, 34, 70, 41, 42, 37, 35, 28, 25, 37, 25, 29, 39, 42, 26, 47, 67, 11, 58, 50, 44, 21, 44, 31, 62, 30, 25, 35, 58, 40, 79, 19, 35, 54, 23, 55, 30, 51, 47, 33, 65, 36, 26, 33, 37, 33, 54, 31, 61, 59, 45, 49, 58, 31, 6, 24, 9, 41, 68, 35, 43, 64, 34, 76, 42, 43, 39, 60, 37, 38, 14, 40, 42, 65, 76, 56, 67, 43, 39, 45, 33, 21, 21, 41, 15, 9, 15, 49, 57, 58, 46, 58, 68, 21, 79, 51, 70, 19, 26, 37, 42, 51, 32, 16, 32, 15, 57, 36, 72, 43, 29, 28, 57, 42, 54, 19, 28, 46, 34, 47, 43, 57, 60, 54, 34, 41, 60, 30, 58, 48, 37, 48, 56, 64, 63, 57, 30, 44, 60, 48, 50, 32, 68, 52, 59, 69, 40, 34, 51, 79, 21, 47, 60, 65, 27, 50, 22, 38, 40, 41, 7, 59, 59, 24, 24, 55, 48, 43, 41, 37, 56, 55, 26, 51, 35, 33, 48, 33, 42, 40, 41, 52, 37, 14, 67, 34, 3, 14, 82, 58, 32, 46, 49, 59, 44, 18, 27, 34, 49, 63, 49, 16, 26, 61, 38, 42, 12, 13, 54, 18, 33, 38, 53, 38, 38, 34, 49, 40, 42, 26, 18, 28, 33, 30, 45, 47, 12, 60, 37, 73, 61, 31, 6, 37, 27, 21, 26, 39, 37, 30, 35, 60, 38, 49, 32, 74, 30, 43, 74, 29, 34, 51, 51, 33, 29, 41, 36, 33, 65, 49, 32, 56, 22, 41, 53, 59, 27, 27, 38, 35, 37, 42, 63, 45, 35, 61, 53, 37, 57, 44, 32, 24, 40, 40, 37, 53, 48, 18, 40, 62, 49, 65, 16, 24, 64, 55, 37, 50, 60, 49, 41, 70, 50, 41, 26, 46, 41, 30, 43, 40, 32, 41, 31, 31, 20, 41, 28, 22, 59, 36, 38, 42, 38, 16, 59, 52, 49, 26, 34, 43, 24, 20, 48, 39, 14, 25, 24, 29, 43, 37, 50, 20, 43, 71, 53, 39, 52, 29, 35, 55, 43, 30, 70, 16, 49, 59, 44, 47, 34, 56, 53, 29, 41, 46, 40, 39, 28, 23, 26, 36, 61, 41, 38, 46, 49, 34, 36, 14, 34, 48, 21, 33, 22, 35, 51, 35, 14, 54, 53, 41, 52, 48, 39, 36, 44, 36, 41, 45, 56, 32, 21, 64, 48, 24, 32, 29, 33, 34, 38, 41, 54, 33, 27, 29, 59, 43, 37, 27, 50, 25, 38, 23, 61, 47, 48, 60, 45, 30, 14, 35, 57, 39, 29, 40, 32, 40, 43, 47, 33, 47, 42, 34, 50, 23, 24, 26, 31, 28, 49, 30, 56, 9, 30, 30, 45, 17, 54, 58, 16, 17, 39, 32, 53, 38, 23, 46, 33, 12, 39, 31, 44, 46, 62, 35, 68, 45, 54, 47, 30, 50, 43, 60, 44, 12, 50, 28, 60, 66, 45, 38, 50, 31, 26, 40, 25, 25, 31, 54, 50, 53, 23, 18, 54, 53, 49, 66, 52, 12, 28, 60, 25, 54, 72, 48, 33, 46, 44, 44, 37, 54, 63, 33, 41, 32, 43, 35, 79, 52, 41, 68, 22, 53, 29, 31, 43, 43, 63, 37, 44, 43, 17, 36, 34, 58, 54, 54, 26, 27, 26, 49, 22, 51, 39, 57, 31, 32, 8, 44, 16, 23, 30, 51, 27, 54, 37, 32, 55, 41, 25, 39, 54, 15, 22, 47, 34, 61, 27, 53, 45, 44, 35, 41, 52, 42, 39, 45, 65, 61, 67, 43, 40, 38, 43, 44, 31, 35, 63, 57, 47, 28, 21, 36, 57, 54, 52, 32, 53, 23, 62, 22, 33, 32, 48, 39, 43, 20, 49, 51, 54, 46, 31, 41, 12, 49, 20, 36, 37, 62, 32, 33, 31, 34, 52, 35, 62, 24, 50, 52, 25, 8, 31, 22, 60, 52, 33, 57, 63, 59, 42, 28, 50, 25, 35, 56, 70, 65, 64, 46, 55, 16, 21, 44, 51, 39, 62, 46, 50, 53, 26, 24, 32, 26, 62, 17, 36, 55, 42, 50, 44, 43, 45, 22, 19, 62, 18, 35, 56, 27, 47, 42, 47, 7, 42, 29, 49, 50, 52, 42, 17, 53, 41, 53, 42, 45, 54, 63, 56, 23, 57, 45, 34, 29, 34, 14, 38, 42, 38, 43, 57, 32, 23, 42, 25, 16, 28, 39, 30, 54, 36, 32, 52, 83, 80, 35, 19, 23, 23, 34, 20, 46, 20, 57, 52, 34, 50, 48, 40, 51, 51, 65, 37, 8, 43, 40, 35, 38, 61, 22, 41, 56, 62, 30, 51, 29, 29, 51, 35, 39, 39, 28, 18, 53, 22, 47, 5, 30, 34, 30, 71, 57, 44, 58, 43, 56, 36, 38, 24, 33, 43, 28, 51, 36, 43, 68, 37, 49, 41, 9, 33, 42, 68, 45, 24, 50, 67, 47, 66, 50, 43, 15, 69, 42, 25, 48, 65, 37, 42, 65, 31, 45, 27, 34, 41, 68, 40, 21, 33, 19, 51, 39, 15, 19, 48, 53, 40, 83, 8, 50, 59, 47, 52, 60, 43, 57, 37, 49, 45, 52, 57, 10, 53, 25, 32, 58, 40, 33, 44, 32, 36, 44, 39, 19, 40, 54, 21, 48, 51, 37, 58, 14, 40, 55, 74, 37, 33, 30, 39, 72, 40, 34, 15, 34, 60, 55, 42, 38, 44, 51, 43, 12, 44, 43, 46, 15, 73, 37, 25, 9, 67, 30, 39, 59, 36, 19, 57, 31, 29, 36, 23, 13, 32, 50, 25, 39, 57, 48, 28, 45, 52, 31, 37, 53, 33, 47, 24, 33, 36, 62, 38, 29, 80, 27, 54, 42, 27, 61, 48, 13, 61, 53, 46, 19, 28, 42, 49, 43, 50, 34, 35, 17, 24, 44, 57, 17, 15, 21, 45, 25, 40, 38, 27, 31, 35, 46, 23, 25, 31, 61, 19, 38, 50, 29, 34, 36, 55, 34, 48, 68, 37, 37, 80, 26, 31, 23, 52, 26, 42, 20, 22, 61, 20, 42, 28, 34, 51, 38, 71, 60, 39, 39, 27, 34, 37, 14, 50, 38, 58, 55, 43, 20, 33, 44, 39, 32, 12, 35, 36, 53, 23, 23, 29, 14, 45, 53, 53, 61, 22, 78, 39, 46, 40, 60, 64, 39, 32, 32, 43, 13, 40, 15, 36, 55, 67, 39, 15, 29, 29, 56, 44, 66, 43, 50, 31, 40, 37, 54, 39, 42, 40, 25, 17, 32, 38, 59, 38, 26, 28, 7, 28, 60, 24, 36, 41, 45, 41, 22, 43, 40, 26, 24, 44, 39, 21, 38, 44, 44, 51, 25, 65, 59, 34, 27, 47, 43, 45, 14, 42, 20, 31, 16, 31, 35, 36, 45, 52, 48, 32, 40, 58, 27, 30, 23, 53, 25, 48, 35, 75, 13, 36, 38, 39, 49, 69, 20, 41, 58, 26, 45, 48, 17, 29, 49, 38, 27, 45, 17, 40, 68, 16, 17, 41, 50, 26, 20, 28, 36, 23, 27, 39, 46, 25, 24, 47, 60, 44, 47, 29, 25, 58, 36, 39, 53, 33, 35, 48, 41, 39, 34, 16, 64, 50, 45, 53, 16, 37, 59, 51, 50, 30, 59, 20, 15, 39, 65, 40, 25, 36, 53, 40, 57, 42, 48, 66, 26, 51, 25, 41, 75, 54, 34, 52, 15, 56, 41, 49, 42, 26, 26, 33, 64, 46, 45, 14, 33, 60, 26, 59, 58, 53, 27, 51, 15, 41, 10, 33, 22, 31, 48, 21, 51, 27, 18, 37, 49, 51, 37, 68, 21, 35, 69, 42, 29, 41, 34, 64, 15, 28, 35, 38, 50, 50, 34, 62, 59, 27, 53, 23, 43, 48, 33, 15, 55, 40, 54, 37, 34, 31, 26, 50, 28, 44, 22, 59, 43, 40, 47, 34, 61, 34, 44, 42, 54, 57, 50, 46, 37, 21, 26, 39, 61, 33, 37, 45, 28, 44, 20, 50, 24, 40, 36, 44, 44, 44, 22, 73, 49, 18, 16, 39, 61, 31, 48, 20, 27, 59, 31, 45, 43, 32, 46, 29, 46, 16, 28, 35, 45, 42, 32, 29, 69, 35, 43, 25, 56, 53, 31, 34, 21, 60, 30, 59, 41, 42, 59, 49, 37, 30, 28, 61, 17, 52, 23, 33, 34, 36, 19, 45, 46, 27, 25, 33, 38, 50, 24, 19, 34, 51, 35, 38, 33, 36, 34, 25, 34, 33, 39, 20, 56, 30, 26, 27, 42, 65, 42, 55, 38, 38, 43, 45, 43, 9, 51, 58, 34, 39, 64, 42, 20, 47, 26, 26, 22, 47, 46, 41, 49, 19, 46, 73, 41, 32, 19, 57, 65, 22, 17, 26, 26, 46, 66, 47, 61, 70, 38, 42, 56, 34, 36, 52, 34, 59, 66, 69, 58, 29, 48, 21, 48, 50, 28, 42, 30, 55, 42, 39, 69, 50, 76, 55, 54, 40, 58, 39, 54, 31, 39, 50, 32, 49, 45, 61, 39, 38, 45, 49, 52, 43, 27, 19, 59, 35, 23, 55, 34, 32, 61, 22, 33, 51, 23, 17, 52, 62, 59, 54, 48, 24, 27, 22, 58, 28, 29, 7, 33, 60, 50, 56, 10, 11, 42, 35, 56, 53, 18, 37, 24, 70, 28, 35, 35, 13, 23, 46, 19, 29, 52, 49, 55, 45, 28, 47, 37, 40, 42, 67, 28, 37, 16, 27, 43, 41, 40, 54, 60, 38, 45, 65, 21, 33, 55, 34, 44, 29, 45, 34, 65, 60, 10, 44, 28, 21, 53, 54, 48, 41, 34, 41, 32, 42, 18, 31, 22, 45, 54, 44, 49, 22, 37, 41, 59, 32, 35, 37, 38, 66, 49, 53, 30, 31, 18, 49, 14, 56, 40, 27, 18, 16, 16, 31, 66, 46, 41, 21, 54, 51, 51, 42, 43, 31, 36, 32, 17, 35, 30, 29, 38, 47, 32, 13, 57, 45, 35, 60, 38]}, 'test_1': {'capacity': 100, 'num_items': 5000, 'items': [42, 57, 41, 42, 43, 30, 26, 21, 42, 24, 37, 52, 50, 32, 76, 58, 69, 35, 30, 42, 40, 28, 63, 60, 42, 46, 38, 39, 45, 43, 53, 72, 26, 41, 39, 19, 63, 43, 32, 29, 48, 33, 29, 17, 44, 13, 57, 48, 12, 60, 51, 27, 55, 40, 22, 63, 37, 53, 34, 25, 41, 54, 36, 46, 43, 44, 41, 42, 20, 35, 31, 32, 72, 36, 20, 26, 26, 65, 48, 31, 71, 43, 46, 36, 33, 52, 32, 35, 56, 35, 29, 36, 61, 50, 66, 36, 29, 13, 60, 43, 40, 66, 49, 28, 48, 23, 35, 55, 84, 50, 50, 39, 33, 45, 42, 40, 27, 26, 21, 54, 30, 59, 18, 41, 52, 8, 19, 64, 41, 38, 50, 53, 65, 20, 15, 18, 36, 27, 27, 30, 43, 10, 33, 55, 26, 28, 48, 50, 36, 43, 39, 42, 48, 8, 46, 21, 15, 59, 33, 41, 40, 46, 44, 33, 42, 30, 32, 57, 30, 32, 30, 30, 41, 77, 49, 14, 54, 56, 68, 53, 24, 31, 29, 43, 22, 16, 26, 47, 18, 46, 29, 13, 47, 33, 44, 40, 60, 22, 66, 55, 37, 41, 37, 32, 37, 53, 77, 42, 28, 35, 32, 28, 27, 63, 36, 38, 61, 40, 17, 66, 53, 45, 55, 24, 3, 45, 53, 43, 59, 70, 45, 33, 68, 44, 39, 64, 56, 27, 42, 24, 54, 61, 51, 34, 58, 44, 44, 45, 56, 38, 40, 14, 57, 51, 25, 15, 35, 57, 51, 45, 16, 30, 29, 31, 45, 35, 47, 20, 20, 20, 34, 57, 61, 37, 34, 23, 31, 40, 46, 49, 59, 41, 39, 42, 23, 44, 29, 32, 31, 35, 19, 20, 54, 12, 35, 53, 40, 70, 39, 31, 43, 38, 28, 33, 38, 50, 33, 19, 30, 60, 45, 30, 43, 39, 47, 40, 33, 32, 15, 26, 53, 51, 63, 27, 55, 34, 56, 26, 56, 52, 42, 45, 39, 35, 65, 47, 33, 26, 50, 63, 24, 32, 34, 24, 47, 51, 66, 45, 42, 30, 49, 57, 40, 21, 21, 43, 31, 42, 33, 11, 75, 46, 40, 43, 34, 43, 38, 56, 42, 28, 51, 27, 44, 51, 28, 53, 41, 27, 27, 36, 50, 48, 56, 68, 28, 45, 54, 56, 33, 49, 26, 29, 33, 30, 53, 39, 26, 51, 19, 39, 27, 29, 56, 32, 40, 55, 40, 21, 32, 32, 19, 18, 54, 41, 27, 46, 43, 31, 17, 46, 31, 39, 39, 56, 34, 40, 23, 32, 28, 38, 21, 50, 51, 21, 37, 28, 35, 34, 48, 10, 45, 46, 62, 10, 24, 56, 60, 46, 54, 42, 47, 40, 20, 58, 45, 41, 16, 25, 72, 58, 42, 55, 36, 39, 31, 34, 6, 53, 52, 31, 46, 43, 24, 78, 56, 12, 43, 30, 59, 38, 48, 32, 11, 33, 36, 22, 53, 34, 70, 45, 40, 38, 30, 31, 70, 46, 20, 72, 35, 22, 32, 39, 44, 58, 34, 32, 41, 81, 52, 62, 27, 50, 29, 51, 40, 37, 48, 50, 48, 45, 9, 16, 33, 42, 50, 66, 16, 12, 77, 21, 58, 22, 38, 12, 27, 57, 19, 61, 41, 33, 25, 35, 61, 60, 66, 22, 56, 59, 34, 35, 38, 53, 53, 40, 36, 13, 27, 25, 35, 35, 66, 41, 64, 47, 62, 50, 36, 48, 33, 41, 39, 45, 49, 35, 63, 37, 16, 42, 35, 45, 24, 48, 35, 48, 21, 14, 22, 63, 26, 23, 40, 59, 48, 58, 44, 32, 69, 72, 41, 41, 51, 15, 29, 22, 42, 49, 40, 35, 48, 18, 29, 23, 25, 28, 54, 19, 13, 67, 37, 43, 31, 13, 46, 30, 29, 47, 48, 46, 49, 31, 38, 40, 54, 39, 49, 49, 50, 16, 20, 33, 46, 59, 33, 46, 49, 36, 41, 32, 44, 52, 49, 76, 32, 42, 45, 52, 47, 38, 21, 49, 22, 63, 35, 34, 51, 42, 73, 30, 62, 55, 25, 56, 51, 48, 49, 51, 52, 24, 55, 50, 25, 17, 30, 31, 33, 25, 47, 29, 38, 16, 28, 35, 51, 40, 4, 52, 15, 30, 27, 41, 43, 72, 21, 52, 47, 22, 51, 71, 29, 62, 38, 26, 64, 19, 32, 49, 39, 47, 56, 39, 51, 36, 51, 36, 57, 79, 41, 40, 47, 30, 31, 54, 45, 16, 22, 40, 46, 23, 27, 53, 53, 33, 19, 9, 11, 56, 45, 34, 37, 53, 50, 36, 48, 49, 40, 49, 32, 45, 19, 48, 33, 33, 36, 52, 32, 50, 27, 31, 19, 30, 21, 54, 68, 64, 28, 56, 8, 55, 34, 22, 54, 30, 60, 37, 29, 18, 20, 10, 17, 19, 27, 41, 35, 34, 55, 28, 51, 35, 22, 47, 41, 44, 46, 28, 20, 22, 28, 47, 50, 86, 43, 50, 20, 13, 55, 54, 45, 50, 51, 21, 53, 42, 45, 46, 39, 48, 47, 35, 14, 29, 29, 56, 57, 51, 42, 21, 40, 26, 55, 41, 32, 37, 16, 58, 52, 42, 58, 35, 61, 38, 15, 54, 8, 44, 47, 30, 69, 36, 42, 27, 28, 45, 45, 68, 18, 50, 55, 21, 32, 36, 33, 48, 29, 42, 23, 65, 37, 31, 25, 37, 52, 39, 11, 26, 51, 80, 35, 37, 40, 40, 31, 67, 35, 36, 41, 72, 34, 64, 17, 35, 44, 22, 37, 67, 49, 65, 53, 52, 40, 34, 35, 22, 43, 17, 43, 56, 46, 31, 16, 39, 39, 47, 58, 47, 43, 32, 18, 42, 48, 61, 46, 37, 46, 61, 57, 41, 29, 34, 17, 53, 18, 51, 44, 38, 55, 44, 59, 32, 64, 19, 30, 12, 34, 45, 35, 26, 20, 33, 9, 12, 52, 29, 23, 28, 28, 59, 34, 30, 51, 45, 9, 22, 34, 33, 17, 29, 45, 13, 15, 24, 51, 24, 48, 27, 33, 53, 28, 16, 34, 35, 37, 11, 57, 17, 59, 30, 36, 60, 69, 48, 33, 32, 35, 50, 29, 34, 55, 12, 28, 12, 42, 33, 50, 62, 14, 61, 50, 43, 56, 22, 45, 32, 26, 63, 19, 6, 24, 28, 25, 31, 38, 48, 73, 49, 29, 16, 37, 50, 54, 56, 19, 61, 47, 31, 28, 42, 66, 45, 75, 55, 27, 13, 16, 49, 26, 28, 66, 24, 35, 59, 38, 47, 23, 19, 34, 30, 49, 36, 48, 25, 5, 27, 46, 46, 22, 54, 9, 61, 17, 41, 43, 34, 29, 56, 44, 38, 36, 23, 31, 60, 44, 23, 38, 33, 20, 28, 28, 56, 45, 25, 40, 51, 55, 38, 36, 48, 45, 62, 66, 58, 30, 36, 40, 55, 36, 51, 57, 24, 49, 32, 29, 26, 45, 33, 39, 36, 55, 21, 17, 23, 38, 26, 72, 48, 46, 40, 58, 36, 39, 45, 31, 31, 48, 69, 22, 18, 65, 47, 56, 51, 32, 37, 29, 30, 38, 32, 30, 34, 34, 38, 46, 35, 33, 28, 54, 53, 78, 35, 60, 48, 32, 22, 35, 47, 20, 24, 20, 35, 50, 36, 58, 29, 40, 45, 22, 20, 27, 77, 24, 40, 31, 45, 50, 57, 47, 42, 34, 42, 48, 64, 43, 35, 44, 21, 26, 48, 32, 32, 22, 38, 30, 35, 40, 64, 32, 49, 28, 15, 43, 54, 22, 61, 45, 45, 39, 48, 39, 74, 52, 55, 50, 51, 42, 32, 29, 28, 13, 42, 39, 53, 48, 35, 45, 31, 38, 39, 26, 54, 23, 45, 30, 58, 31, 29, 47, 19, 74, 22, 41, 20, 70, 25, 32, 62, 16, 22, 64, 17, 50, 24, 49, 33, 20, 54, 15, 32, 67, 57, 38, 65, 35, 50, 55, 51, 23, 65, 31, 53, 36, 34, 49, 65, 32, 62, 33, 49, 52, 33, 47, 29, 36, 45, 24, 44, 30, 71, 32, 37, 36, 48, 48, 23, 36, 55, 23, 30, 37, 30, 48, 22, 39, 25, 27, 49, 34, 28, 33, 52, 55, 36, 60, 29, 44, 52, 48, 55, 16, 51, 41, 35, 30, 48, 33, 55, 24, 56, 50, 36, 49, 15, 37, 64, 56, 41, 15, 38, 21, 31, 61, 54, 32, 52, 41, 65, 41, 53, 37, 35, 23, 56, 40, 53, 11, 34, 53, 27, 48, 47, 80, 20, 57, 64, 44, 56, 26, 10, 31, 21, 32, 19, 26, 42, 27, 43, 59, 20, 70, 47, 17, 42, 13, 40, 45, 13, 47, 32, 42, 39, 63, 22, 30, 67, 63, 65, 37, 32, 53, 36, 43, 50, 12, 37, 39, 29, 35, 41, 40, 44, 50, 62, 33, 49, 43, 27, 46, 43, 13, 49, 49, 19, 42, 34, 44, 61, 59, 27, 30, 33, 45, 20, 21, 66, 47, 51, 49, 49, 32, 20, 74, 33, 66, 49, 45, 33, 29, 32, 18, 7, 37, 64, 43, 65, 25, 35, 45, 30, 31, 58, 29, 20, 9, 35, 13, 26, 41, 24, 50, 20, 64, 39, 35, 68, 40, 54, 48, 48, 67, 43, 51, 38, 35, 50, 65, 30, 46, 64, 27, 7, 46, 68, 53, 37, 66, 37, 3, 65, 50, 38, 31, 32, 29, 64, 34, 21, 32, 47, 27, 38, 31, 50, 54, 55, 34, 30, 24, 37, 42, 26, 24, 30, 46, 54, 29, 34, 39, 36, 16, 57, 50, 25, 21, 37, 43, 39, 40, 49, 44, 46, 13, 28, 41, 62, 32, 36, 30, 56, 37, 38, 72, 6, 47, 39, 37, 74, 36, 53, 31, 34, 28, 27, 47, 45, 54, 23, 50, 28, 49, 43, 45, 65, 21, 17, 35, 21, 16, 20, 47, 17, 45, 29, 24, 61, 50, 28, 26, 46, 18, 40, 27, 42, 46, 48, 24, 36, 23, 61, 55, 62, 56, 28, 36, 73, 61, 48, 41, 6, 18, 46, 48, 38, 48, 68, 26, 41, 28, 54, 36, 58, 27, 49, 40, 16, 44, 69, 36, 23, 35, 45, 55, 58, 39, 24, 43, 32, 45, 46, 50, 30, 44, 61, 57, 37, 45, 72, 33, 30, 50, 28, 23, 26, 36, 51, 36, 44, 37, 27, 38, 29, 47, 55, 27, 31, 17, 36, 53, 74, 44, 47, 36, 37, 35, 54, 26, 52, 34, 31, 49, 61, 27, 31, 29, 21, 47, 69, 49, 27, 49, 44, 41, 60, 57, 48, 48, 65, 50, 41, 53, 26, 47, 38, 22, 18, 44, 23, 52, 48, 45, 41, 18, 38, 42, 21, 45, 72, 46, 35, 49, 54, 54, 20, 43, 42, 63, 45, 38, 14, 22, 55, 51, 37, 12, 52, 38, 20, 43, 45, 78, 24, 21, 23, 20, 29, 24, 37, 46, 38, 22, 38, 33, 40, 31, 30, 25, 50, 14, 47, 29, 20, 56, 20, 42, 35, 44, 49, 68, 34, 15, 46, 40, 31, 57, 28, 35, 37, 16, 46, 12, 67, 39, 21, 23, 41, 59, 50, 13, 36, 73, 41, 29, 44, 45, 47, 59, 72, 51, 61, 23, 22, 27, 55, 37, 12, 57, 37, 67, 36, 17, 50, 29, 39, 41, 39, 32, 46, 47, 41, 42, 67, 45, 28, 37, 37, 59, 55, 51, 35, 18, 48, 46, 82, 35, 40, 62, 46, 20, 11, 50, 40, 11, 32, 35, 26, 63, 36, 35, 45, 61, 43, 50, 19, 17, 54, 55, 51, 35, 52, 38, 62, 37, 53, 40, 56, 25, 14, 36, 48, 56, 36, 19, 31, 45, 28, 52, 36, 40, 82, 33, 42, 50, 33, 19, 28, 13, 67, 63, 28, 44, 21, 85, 21, 34, 23, 60, 37, 53, 33, 49, 49, 56, 75, 37, 52, 37, 58, 42, 39, 31, 24, 54, 37, 29, 60, 58, 42, 27, 31, 53, 42, 43, 54, 47, 19, 26, 19, 45, 24, 30, 41, 26, 31, 46, 7, 48, 40, 47, 34, 30, 32, 33, 61, 48, 34, 48, 38, 51, 33, 22, 40, 49, 36, 46, 54, 64, 61, 50, 47, 44, 65, 65, 47, 31, 28, 30, 45, 43, 36, 51, 44, 66, 49, 19, 23, 45, 35, 17, 18, 37, 52, 27, 24, 52, 34, 51, 31, 63, 38, 36, 38, 30, 26, 9, 46, 54, 26, 29, 49, 23, 46, 40, 19, 23, 46, 29, 44, 46, 20, 15, 25, 30, 63, 60, 38, 30, 38, 35, 33, 35, 39, 51, 22, 34, 26, 26, 17, 34, 9, 21, 17, 23, 41, 18, 15, 44, 41, 30, 57, 43, 36, 40, 44, 32, 35, 44, 16, 41, 27, 46, 58, 47, 47, 25, 32, 42, 37, 22, 29, 21, 46, 33, 40, 77, 34, 18, 37, 33, 51, 65, 36, 38, 59, 48, 40, 22, 41, 17, 44, 39, 44, 22, 28, 41, 41, 62, 52, 41, 45, 54, 62, 39, 59, 48, 19, 54, 40, 45, 30, 33, 49, 26, 51, 42, 54, 48, 38, 33, 41, 27, 49, 51, 80, 29, 43, 56, 17, 29, 30, 32, 34, 41, 19, 38, 50, 15, 34, 54, 12, 24, 58, 31, 69, 26, 49, 52, 37, 55, 32, 46, 47, 54, 27, 33, 30, 36, 38, 28, 69, 43, 50, 45, 58, 59, 21, 41, 16, 41, 33, 16, 57, 28, 16, 13, 42, 19, 45, 52, 37, 23, 60, 27, 77, 32, 50, 49, 59, 44, 27, 46, 28, 53, 61, 15, 21, 43, 45, 42, 25, 64, 18, 64, 37, 35, 71, 51, 39, 23, 13, 3, 21, 71, 27, 37, 37, 71, 22, 58, 55, 46, 52, 69, 44, 30, 60, 14, 31, 32, 54, 48, 59, 30, 2, 21, 28, 22, 39, 7, 42, 39, 52, 57, 14, 13, 46, 37, 40, 33, 24, 60, 28, 54, 33, 49, 22, 23, 33, 23, 43, 53, 47, 40, 22, 18, 39, 41, 29, 62, 28, 49, 27, 45, 38, 30, 75, 25, 31, 45, 54, 17, 33, 18, 37, 38, 63, 46, 44, 45, 69, 42, 32, 46, 49, 36, 24, 45, 50, 18, 45, 44, 49, 23, 30, 57, 10, 87, 38, 66, 50, 44, 33, 17, 60, 58, 53, 32, 38, 48, 20, 31, 56, 43, 52, 35, 48, 37, 21, 24, 44, 42, 58, 28, 54, 56, 48, 28, 46, 73, 38, 62, 46, 44, 64, 40, 22, 54, 38, 41, 47, 47, 58, 19, 49, 28, 52, 41, 23, 31, 56, 32, 38, 53, 15, 21, 73, 58, 21, 34, 24, 22, 37, 39, 57, 16, 58, 42, 50, 71, 24, 41, 51, 33, 59, 18, 12, 24, 39, 33, 15, 73, 66, 47, 20, 27, 29, 31, 7, 44, 19, 31, 45, 34, 39, 38, 53, 67, 49, 52, 37, 40, 54, 36, 40, 31, 53, 27, 42, 40, 43, 29, 30, 22, 43, 78, 38, 30, 30, 24, 42, 63, 52, 6, 13, 12, 44, 27, 17, 50, 19, 36, 46, 45, 59, 61, 58, 59, 37, 22, 39, 44, 14, 58, 71, 74, 51, 41, 41, 49, 39, 45, 28, 33, 23, 36, 28, 43, 13, 28, 48, 44, 40, 59, 50, 29, 41, 72, 22, 16, 44, 44, 47, 39, 45, 58, 29, 68, 47, 59, 13, 51, 14, 45, 39, 49, 57, 47, 58, 70, 53, 28, 37, 52, 53, 42, 42, 45, 54, 56, 82, 38, 55, 30, 33, 53, 44, 64, 33, 38, 37, 19, 38, 37, 53, 46, 25, 46, 13, 29, 50, 61, 49, 56, 53, 61, 30, 34, 47, 54, 22, 13, 50, 42, 30, 16, 16, 38, 40, 18, 24, 16, 44, 30, 52, 44, 29, 50, 34, 64, 8, 42, 41, 55, 55, 57, 32, 23, 16, 41, 40, 37, 27, 10, 52, 69, 24, 40, 55, 35, 47, 30, 40, 46, 40, 10, 24, 30, 36, 73, 26, 28, 29, 60, 64, 54, 52, 53, 33, 33, 40, 23, 51, 66, 62, 55, 37, 30, 24, 40, 71, 17, 50, 31, 23, 38, 35, 46, 32, 50, 42, 47, 48, 36, 47, 29, 22, 41, 60, 66, 57, 18, 20, 61, 38, 17, 40, 31, 42, 47, 44, 60, 9, 33, 37, 34, 62, 49, 27, 44, 22, 25, 52, 44, 46, 18, 42, 46, 16, 31, 21, 35, 31, 67, 46, 32, 38, 40, 42, 39, 23, 20, 28, 21, 34, 22, 33, 60, 49, 52, 25, 46, 59, 48, 55, 45, 38, 40, 28, 43, 7, 39, 80, 34, 15, 32, 38, 68, 42, 52, 61, 70, 28, 54, 50, 52, 45, 35, 39, 27, 29, 65, 35, 24, 52, 8, 32, 62, 29, 51, 48, 37, 54, 29, 45, 33, 31, 69, 33, 14, 35, 39, 30, 29, 64, 64, 12, 24, 16, 40, 53, 49, 39, 52, 40, 29, 52, 60, 50, 51, 44, 18, 65, 58, 28, 51, 61, 56, 53, 21, 34, 62, 63, 59, 35, 44, 46, 56, 48, 32, 52, 25, 34, 33, 40, 16, 17, 42, 46, 51, 40, 43, 31, 68, 24, 49, 37, 31, 38, 24, 29, 65, 12, 53, 63, 32, 7, 41, 32, 26, 35, 42, 25, 29, 28, 46, 56, 34, 50, 9, 53, 29, 14, 48, 61, 33, 46, 40, 6, 65, 26, 65, 30, 43, 22, 27, 48, 60, 32, 21, 63, 30, 55, 54, 29, 65, 23, 20, 41, 52, 22, 28, 48, 33, 22, 55, 43, 64, 73, 45, 49, 53, 17, 71, 31, 56, 44, 35, 39, 32, 53, 38, 32, 40, 49, 58, 25, 46, 11, 30, 35, 43, 40, 40, 38, 27, 41, 31, 34, 58, 33, 21, 54, 66, 53, 26, 62, 27, 13, 59, 9, 48, 20, 34, 29, 27, 50, 69, 36, 28, 18, 22, 34, 51, 28, 66, 30, 55, 53, 50, 43, 60, 28, 31, 24, 34, 47, 26, 36, 16, 38, 47, 51, 65, 36, 34, 14, 40, 17, 55, 23, 33, 44, 27, 62, 59, 31, 6, 43, 19, 63, 21, 32, 61, 26, 39, 12, 35, 33, 48, 7, 41, 58, 47, 15, 45, 51, 59, 43, 56, 33, 26, 40, 50, 57, 31, 46, 27, 62, 39, 44, 45, 36, 46, 37, 44, 43, 35, 45, 53, 10, 7, 45, 33, 23, 29, 30, 35, 66, 34, 66, 37, 54, 30, 23, 48, 62, 60, 45, 68, 42, 50, 47, 51, 22, 43, 52, 40, 46, 46, 14, 7, 35, 33, 18, 52, 56, 18, 63, 43, 18, 49, 61, 58, 32, 33, 15, 12, 38, 47, 15, 39, 38, 44, 52, 47, 44, 58, 23, 23, 47, 38, 40, 66, 28, 19, 22, 25, 21, 38, 39, 57, 45, 14, 38, 23, 62, 25, 69, 30, 52, 29, 20, 51, 40, 30, 42, 36, 25, 48, 47, 54, 8, 23, 59, 32, 78, 50, 27, 42, 28, 33, 40, 29, 32, 21, 39, 59, 69, 42, 40, 16, 51, 27, 45, 38, 42, 66, 38, 26, 28, 44, 51, 54, 65, 39, 70, 29, 42, 48, 41, 51, 48, 51, 23, 58, 33, 43, 35, 50, 54, 38, 40, 43, 74, 29, 56, 55, 40, 20, 47, 43, 23, 45, 12, 50, 42, 56, 22, 32, 10, 26, 47, 54, 21, 8, 37, 34, 32, 42, 41, 15, 28, 58, 19, 35, 34, 47, 8, 30, 68, 21, 41, 25, 18, 60, 60, 48, 59, 56, 32, 32, 86, 17, 64, 51, 60, 19, 47, 41, 39, 23, 23, 62, 36, 41, 35, 49, 27, 28, 60, 11, 55, 35, 38, 14, 62, 28, 12, 55, 11, 34, 27, 46, 55, 31, 51, 24, 66, 49, 51, 39, 55, 21, 43, 40, 36, 39, 65, 38, 29, 46, 33, 27, 27, 26, 19, 25, 29, 30, 23, 50, 44, 19, 35, 34, 67, 51, 38, 53, 22, 42, 21, 61, 43, 28, 44, 12, 27, 36, 61, 40, 61, 39, 54, 30, 25, 44, 17, 54, 55, 29, 34, 31, 48, 39, 41, 61, 33, 62, 46, 36, 9, 45, 32, 54, 59, 48, 51, 37, 35, 33, 36, 53, 51, 46, 49, 18, 59, 27, 42, 50, 26, 52, 35, 26, 37, 47, 37, 41, 48, 54, 35, 40, 35, 24, 34, 33, 43, 44, 17, 45, 26, 56, 29, 43, 45, 14, 16, 42, 54, 31, 49, 59, 68, 16, 20, 63, 52, 47, 51, 64, 39, 49, 41, 65, 38, 30, 34, 9, 26, 32, 27, 20, 39, 71, 49, 16, 39, 52, 49, 64, 37, 33, 26, 46, 19, 51, 36, 51, 20, 49, 63, 67, 68, 48, 14, 51, 54, 43, 36, 41, 18, 39, 44, 61, 36, 40, 29, 35, 32, 63, 41, 21, 35, 43, 28, 53, 55, 67, 57, 35, 54, 57, 52, 33, 63, 25, 34, 57, 77, 45, 57, 30, 51, 44, 53, 42, 51, 33, 34, 63, 41, 45, 35, 40, 48, 25, 53, 48, 50, 37, 37, 55, 52, 30, 44, 35, 41, 51, 45, 42, 35, 35, 23, 34, 28, 37, 38, 63, 61, 52, 67, 52, 41, 63, 39, 33, 56, 39, 50, 63, 42, 29, 41, 38, 59, 10, 52, 56, 53, 39, 41, 43, 68, 49, 33, 43, 41, 40, 38, 20, 42, 48, 30, 65, 22, 49, 40, 34, 62, 30, 32, 28, 40, 44, 40, 2, 68, 35, 31, 48, 44, 13, 79, 27, 22, 51, 40, 28, 31, 57, 54, 47, 20, 61, 20, 26, 53, 25, 48, 27, 23, 40, 54, 24, 57, 22, 73, 25, 44, 42, 40, 52, 18, 17, 34, 40, 30, 35, 30, 46, 35, 46, 15, 18, 19, 28, 46, 81, 53, 42, 48, 36, 61, 25, 40, 25, 34, 66, 34, 29, 48, 39, 53, 40, 31, 28, 57, 45, 33, 12, 28, 21, 53, 47, 50, 38, 54, 44, 26, 27, 10, 46, 33, 46, 53, 50, 45, 31, 34, 43, 40, 43, 55, 39, 45, 33, 51, 25, 62, 31, 25, 28, 34, 52, 24, 23, 36, 87, 32, 54, 42, 26, 52, 46, 58, 39, 63, 51, 22, 31, 35, 42, 42, 49, 36, 24, 63, 69, 27, 49, 50, 39, 22, 28, 40, 31, 34, 42, 36, 43, 51, 45, 20, 28, 63, 54, 19, 54, 49, 25, 49, 21, 47, 36, 42, 38, 33, 24, 19, 31, 35, 39, 49, 9, 44, 27, 16, 47, 33, 45, 50, 51, 37, 36, 32, 64, 41, 47, 53, 59, 29, 69, 28, 65, 42, 44, 31, 47, 37, 37, 25, 62, 39, 28, 51, 55, 62, 39, 39, 38, 54, 45, 18, 54, 44, 26, 34, 52, 32, 28, 58, 29, 38, 39, 55, 46, 26, 60, 23, 50, 34, 40, 58, 31, 46, 36, 31, 54, 46, 54, 27, 77, 62, 55, 36, 20, 53, 54, 37, 50, 59, 34, 37, 44, 33, 27, 62, 29, 31, 57, 44, 43, 46, 40, 22, 45, 33, 31, 39, 51, 51, 51, 48, 61, 61, 22, 48, 47, 49, 35, 33, 15, 10, 34, 33, 52, 81, 50, 59, 57, 41, 21, 45, 64, 56, 30, 39, 37, 47, 42, 46, 23, 59, 25, 23, 48, 58, 16, 39, 20, 46, 52, 23, 55, 43, 40, 36, 28, 44, 28, 21, 60, 39, 27, 55, 39, 38, 46, 27, 40, 60, 40, 38, 22, 48, 41, 24, 20, 49, 36, 27, 17, 67, 36, 66, 42, 48, 49, 89, 31, 38, 40, 10, 24, 63, 35, 67, 43, 54, 15, 31, 41, 60, 53, 31, 34, 15, 35, 33, 19, 38, 22, 32, 32, 33, 59, 54, 18, 40, 18, 37, 41, 30, 36, 49, 56, 43, 52, 33, 62, 25, 28, 36, 16, 50, 19, 47, 69, 16, 32, 41, 45, 45, 42, 61, 61, 29, 25, 40, 39, 49, 52, 45, 37, 51, 32, 32, 55, 82, 42, 17, 30, 53, 34, 60, 38, 44, 49, 31, 48, 40, 24, 35, 14, 37, 23, 56, 41, 28, 22, 17, 47, 28, 47, 39, 32, 49, 26, 53, 31, 24, 32, 45, 65, 25, 26, 43, 34, 51, 29, 27, 53, 77, 24, 48, 38, 39, 15, 75, 18, 56, 45, 71, 32, 41, 46, 19, 51, 50, 44, 59, 46, 41, 16, 23, 75, 55, 31, 35, 75, 44, 50, 57, 40, 59, 63, 29, 52, 32, 45, 25, 33, 39, 46, 63, 23, 37, 47, 23, 40, 38, 16, 23, 38, 23, 32, 38, 56, 26, 51, 30, 26, 15, 24, 49, 49, 34, 33, 44, 32, 10, 14, 30, 37, 34, 36, 74, 38, 29, 33, 23, 45, 34, 40, 25, 39, 18, 50, 71, 40, 27, 22, 35, 11, 24, 52, 38, 24, 51, 27, 36, 52, 16, 40, 44, 55, 29, 6, 43, 41, 32, 38, 53, 43, 36, 25, 54, 34, 50, 66, 46, 67, 19, 47, 34, 27, 38, 34, 44, 28, 31, 51, 34, 46, 38, 44, 61, 35, 53, 17, 25, 35, 48, 52, 34, 26, 17, 37, 37, 22, 19, 60, 48, 68, 75, 44, 26, 37, 55, 31, 31, 54, 51, 64, 67, 20, 62, 41, 45, 25, 35, 25, 15, 47, 48, 17, 36, 40, 43, 48, 36, 40, 28, 54, 52, 19, 40, 47, 26, 42, 48, 22, 51, 22, 46, 59, 51, 24, 50, 47, 17, 52, 23, 45, 19, 63, 30, 47, 46, 46, 22, 41, 62, 26, 14, 31, 48, 50, 68, 38, 33, 42, 44, 44, 19, 19, 11, 13, 33, 48, 54, 46, 48, 24, 16, 58, 21, 18, 38, 44, 26, 57, 41, 55, 53, 37, 35, 55, 52, 32, 40, 54, 41, 60, 46, 48, 34, 17, 45, 41, 37, 39, 22, 26, 16, 44, 49, 65, 15, 42, 37, 22, 26, 47, 37, 19, 48, 69, 43, 52, 43, 20, 46, 35, 25, 54, 26, 34, 43, 41, 44, 47, 8, 77, 30, 17, 46, 9, 58, 43, 41, 65, 50, 49, 38, 61, 44, 54, 22, 33, 31, 30, 19, 49, 56, 18, 68, 27, 47, 43, 13, 53, 41, 28, 54, 52, 27, 36, 29, 34, 46, 45, 39, 84, 29, 30, 28, 43, 55, 30, 13, 24, 41, 29, 30, 21, 21, 40, 60, 40, 33, 68, 25, 25, 53, 20, 56, 51, 26, 20, 47, 34, 64, 21, 33, 25, 62, 36, 48, 46, 43, 42, 66, 77, 29, 39, 34, 35, 16, 30, 10, 33, 57, 41, 36, 23, 50, 14, 32, 17, 31, 27, 62, 28, 35, 30, 60, 45, 22, 33, 26, 70, 49, 28, 35, 32, 39, 22, 59, 44, 19, 37, 28, 45, 13, 9, 41, 38, 21, 44, 12, 64, 44, 48, 43, 58, 26, 40, 26, 54, 27, 30, 31, 41, 37, 33, 31, 47, 48, 42, 20, 46, 23, 36, 59, 33, 38, 20, 65, 51, 33, 46, 33, 32, 39, 41, 31, 63, 67, 44, 57, 17, 76, 32, 41, 42, 41, 33, 16, 71, 33, 32, 37, 29, 59, 70, 38, 39, 61, 26, 49, 70, 61, 42, 60, 46, 21, 46, 32, 47, 37, 29, 41, 43, 50, 34, 35, 23, 35, 59, 40, 38, 45, 30, 50, 37, 54, 76, 24, 40, 50, 19, 67, 35, 55, 75, 49, 28, 12, 55, 45, 78, 43, 55, 56, 35, 41, 42, 27, 58, 25, 52, 45, 32, 29, 15, 43, 25, 8, 31, 32, 16, 32, 38, 44, 23, 21, 37, 48, 37, 40, 22, 14, 29, 55, 26, 19, 46, 26, 22, 30, 56, 23, 8, 48, 33, 23, 63, 71, 53, 52, 24, 56, 49, 20, 40, 53, 36, 61, 56, 15, 31, 44, 35, 60, 46, 50, 54, 36, 55, 22, 25, 40, 40, 49, 46, 53, 19, 51, 51, 27, 51, 53, 22, 25, 21, 25, 18, 42, 55, 43, 39, 27, 42, 6, 38, 42, 62, 10, 39, 15, 32, 25, 48, 24, 41, 39, 75, 41, 22, 52, 11, 29, 54, 42, 30, 16, 21, 22, 42, 21, 64, 16, 18, 57, 47, 42, 3, 36, 13, 29, 52, 34, 28, 39, 74, 43, 50, 43, 42, 68, 22, 49, 35, 51, 47, 29, 36, 35, 27, 53, 13, 84, 29, 18, 33, 54, 54, 67, 45, 53, 41, 54, 18, 49, 39, 36, 46, 17, 31, 23, 33, 50, 39, 33, 43, 19, 35, 29, 41, 72, 52, 53, 45, 64, 26, 26, 45, 38, 31, 21, 31, 16, 15, 38, 32, 55, 26, 20, 37, 50, 20, 23, 50, 58, 82, 38, 54, 14, 47, 13, 21, 61, 38, 38, 14, 42, 55, 42, 45, 51, 58, 33, 37, 44, 44, 37, 10, 49, 63, 60, 35, 27, 47, 71, 60, 25, 46, 51, 29, 49, 51, 36, 17, 32, 32, 49, 24, 22, 35, 28, 87, 29, 34, 30, 23, 38, 31, 28, 33, 30, 40, 11, 59, 37, 69, 37, 53, 29, 55, 43, 46, 40, 21, 69, 44, 19, 41, 48, 33, 30, 24, 51, 37, 22, 22, 32, 54, 35, 47, 39, 9, 61, 53, 26, 60, 34, 48, 55, 32, 21, 27, 36, 35, 33, 34, 15, 38, 38, 41, 54, 50, 45, 26, 26, 38, 36, 29, 43, 43, 65, 46, 18, 53, 32, 14, 46, 31, 43, 13, 34, 33, 43, 68, 55, 18, 30, 52, 14, 31, 24, 9, 56, 24, 64, 65, 61, 38, 46, 58, 50, 49, 40, 56, 62, 47, 58, 50, 21, 17, 52, 22, 46, 51, 32, 55, 54, 50, 43, 36, 66, 63, 17, 61, 43, 40, 19, 45, 44, 42, 11, 46, 35, 23, 30, 29, 54, 26, 44, 16, 43, 26, 60, 32, 21, 11, 28, 37, 41, 46, 29, 60, 36, 46, 38, 59, 49, 31, 13, 28, 44, 50, 36, 34, 46, 38, 45, 54, 54, 37, 38, 30, 26, 47, 56, 52, 35, 40, 32, 34, 37, 44, 58, 43, 46, 83, 44, 32, 24, 39, 47, 16, 49, 11, 37, 52, 20, 43, 25, 46, 14, 44, 21, 45, 62, 15, 36, 26, 29, 47, 58, 42, 38, 40, 39, 26, 25, 21, 44, 28, 55, 57, 43, 34, 49, 19, 50, 34, 21, 31, 50, 35, 34, 51, 41, 69, 66, 21, 44, 26, 22, 47, 66, 43, 43, 65, 28, 30, 30, 25, 12, 31, 55, 28, 39, 33, 41, 33, 46, 9, 40, 65, 41, 27, 47, 50, 12, 19, 50, 52, 33, 49, 38, 39, 42, 67, 55, 36, 47, 23, 54, 34, 32]}, 'test_2': {'capacity': 100, 'num_items': 5000, 'items': [20, 47, 39, 29, 7, 45, 45, 18, 39, 48, 15, 25, 33, 40, 52, 32, 33, 30, 11, 57, 15, 44, 22, 23, 83, 19, 34, 17, 14, 34, 50, 36, 52, 62, 48, 68, 40, 33, 27, 18, 25, 37, 39, 46, 35, 50, 60, 66, 52, 32, 31, 25, 62, 38, 54, 31, 58, 34, 20, 42, 57, 19, 21, 30, 21, 29, 20, 47, 43, 31, 34, 70, 19, 27, 17, 61, 53, 20, 69, 37, 32, 40, 49, 47, 26, 55, 52, 62, 41, 53, 17, 16, 42, 43, 49, 41, 41, 38, 25, 41, 42, 28, 14, 40, 50, 47, 16, 26, 38, 46, 35, 39, 77, 14, 55, 51, 43, 41, 23, 27, 60, 60, 38, 14, 31, 54, 23, 44, 44, 32, 32, 27, 24, 40, 51, 8, 46, 29, 10, 48, 65, 31, 55, 13, 23, 50, 28, 13, 38, 60, 27, 32, 22, 25, 45, 54, 38, 35, 23, 60, 77, 77, 24, 27, 28, 45, 17, 54, 45, 55, 42, 32, 42, 67, 55, 33, 57, 41, 35, 16, 35, 36, 45, 23, 24, 34, 35, 37, 48, 57, 57, 46, 47, 51, 59, 60, 42, 31, 63, 40, 31, 37, 11, 20, 49, 51, 33, 49, 53, 31, 51, 44, 39, 30, 41, 17, 43, 51, 33, 17, 39, 42, 38, 52, 55, 46, 55, 45, 58, 43, 59, 40, 42, 5, 45, 31, 28, 36, 52, 53, 48, 47, 9, 38, 45, 27, 34, 38, 47, 51, 34, 44, 40, 14, 67, 56, 30, 25, 42, 37, 21, 31, 69, 51, 46, 45, 55, 26, 58, 45, 50, 58, 44, 66, 27, 23, 28, 50, 39, 74, 30, 12, 24, 18, 27, 40, 55, 59, 58, 37, 29, 17, 17, 37, 21, 16, 41, 17, 39, 33, 42, 30, 60, 31, 32, 23, 32, 28, 17, 60, 24, 36, 29, 25, 81, 43, 44, 51, 51, 46, 28, 32, 36, 57, 39, 32, 31, 46, 35, 25, 70, 46, 50, 53, 50, 35, 49, 30, 33, 64, 41, 25, 29, 47, 26, 61, 54, 64, 29, 35, 35, 58, 47, 26, 58, 8, 66, 41, 64, 52, 22, 34, 38, 17, 14, 44, 33, 24, 36, 56, 49, 29, 35, 23, 15, 49, 79, 42, 36, 18, 50, 32, 27, 44, 36, 50, 51, 24, 83, 48, 35, 33, 37, 14, 32, 33, 34, 38, 40, 63, 31, 41, 51, 34, 71, 56, 37, 46, 52, 62, 36, 35, 57, 43, 26, 36, 43, 53, 17, 66, 39, 23, 42, 39, 17, 53, 57, 32, 44, 32, 44, 30, 53, 32, 41, 22, 38, 39, 15, 22, 45, 46, 59, 35, 31, 14, 37, 38, 24, 33, 53, 29, 39, 37, 61, 36, 47, 37, 29, 25, 47, 42, 31, 41, 59, 55, 28, 44, 49, 50, 33, 41, 51, 43, 32, 58, 55, 38, 49, 38, 36, 40, 54, 72, 53, 51, 42, 47, 49, 48, 57, 52, 33, 27, 33, 28, 41, 22, 48, 25, 50, 23, 41, 36, 54, 55, 25, 53, 26, 8, 47, 44, 48, 26, 8, 50, 39, 44, 68, 44, 70, 50, 44, 52, 39, 64, 41, 64, 52, 38, 16, 20, 11, 41, 25, 29, 35, 37, 17, 21, 46, 40, 32, 25, 14, 57, 29, 31, 20, 32, 48, 70, 48, 20, 61, 57, 25, 59, 35, 80, 27, 26, 54, 45, 54, 50, 46, 23, 48, 31, 40, 27, 43, 24, 48, 61, 36, 41, 41, 31, 42, 55, 49, 48, 37, 20, 35, 45, 37, 11, 32, 54, 50, 4, 24, 61, 48, 63, 38, 43, 38, 27, 20, 52, 22, 11, 38, 53, 27, 43, 26, 40, 47, 38, 42, 56, 52, 72, 53, 40, 25, 50, 43, 49, 32, 55, 25, 51, 37, 41, 56, 47, 37, 57, 29, 27, 60, 34, 42, 61, 46, 31, 38, 54, 48, 34, 55, 59, 38, 43, 22, 27, 28, 29, 30, 53, 60, 16, 55, 13, 39, 29, 28, 44, 42, 53, 60, 33, 48, 48, 44, 40, 57, 50, 59, 28, 31, 65, 23, 27, 44, 46, 57, 36, 60, 23, 23, 58, 51, 47, 15, 57, 50, 33, 14, 42, 44, 19, 24, 42, 40, 51, 37, 33, 50, 39, 38, 28, 31, 49, 55, 68, 42, 81, 21, 38, 55, 49, 39, 31, 36, 59, 62, 62, 79, 36, 55, 57, 23, 24, 32, 18, 53, 34, 70, 32, 38, 40, 43, 41, 35, 30, 53, 24, 47, 38, 36, 30, 52, 28, 67, 58, 23, 29, 33, 21, 54, 42, 44, 41, 33, 52, 35, 42, 39, 44, 50, 34, 53, 29, 50, 26, 8, 41, 39, 25, 48, 34, 45, 30, 35, 38, 57, 65, 34, 33, 47, 28, 42, 62, 42, 12, 31, 51, 13, 51, 47, 28, 76, 54, 34, 66, 18, 51, 32, 27, 48, 46, 15, 36, 43, 58, 35, 32, 41, 43, 16, 52, 22, 70, 19, 34, 25, 45, 27, 41, 33, 43, 47, 43, 62, 29, 62, 56, 33, 23, 72, 66, 44, 28, 29, 16, 20, 55, 53, 48, 59, 44, 44, 39, 14, 42, 40, 47, 67, 28, 51, 19, 44, 42, 41, 50, 12, 47, 37, 38, 11, 31, 51, 25, 29, 5, 22, 32, 51, 44, 56, 61, 43, 16, 50, 38, 20, 62, 70, 31, 37, 30, 69, 46, 13, 19, 45, 20, 10, 42, 34, 64, 56, 10, 35, 41, 32, 34, 48, 61, 55, 37, 49, 40, 26, 42, 35, 44, 41, 62, 29, 34, 34, 41, 54, 55, 35, 34, 37, 30, 29, 36, 62, 35, 38, 45, 31, 35, 37, 43, 38, 48, 45, 43, 28, 50, 49, 42, 64, 29, 75, 47, 60, 30, 55, 56, 62, 48, 35, 36, 22, 43, 56, 30, 37, 41, 21, 31, 60, 56, 15, 38, 32, 53, 25, 26, 36, 65, 40, 30, 42, 54, 47, 10, 11, 36, 61, 31, 53, 33, 21, 58, 42, 39, 43, 83, 44, 26, 25, 52, 10, 30, 29, 45, 30, 56, 39, 12, 38, 56, 33, 29, 31, 42, 36, 25, 24, 44, 54, 43, 48, 29, 38, 57, 50, 21, 67, 42, 28, 38, 22, 68, 11, 38, 15, 28, 58, 47, 24, 43, 50, 27, 17, 38, 20, 39, 53, 34, 61, 37, 57, 30, 20, 33, 65, 43, 44, 65, 38, 38, 15, 69, 49, 40, 30, 41, 14, 45, 43, 27, 56, 30, 45, 53, 39, 72, 32, 35, 15, 48, 18, 66, 54, 58, 44, 40, 40, 48, 25, 33, 62, 38, 43, 38, 20, 21, 29, 45, 35, 41, 61, 48, 25, 42, 36, 25, 34, 51, 39, 46, 53, 68, 21, 26, 18, 49, 49, 12, 29, 29, 46, 63, 38, 32, 49, 67, 28, 39, 19, 42, 55, 44, 44, 29, 26, 29, 33, 24, 22, 22, 57, 55, 29, 19, 34, 59, 43, 45, 37, 58, 80, 28, 76, 39, 51, 20, 32, 55, 34, 43, 65, 14, 60, 41, 33, 30, 35, 38, 51, 37, 49, 33, 43, 34, 21, 91, 9, 67, 41, 52, 24, 45, 35, 38, 35, 33, 37, 52, 42, 37, 45, 24, 44, 38, 32, 47, 38, 47, 65, 73, 31, 47, 46, 29, 70, 35, 36, 19, 34, 59, 46, 23, 31, 31, 21, 33, 32, 32, 43, 43, 23, 66, 52, 20, 35, 51, 47, 23, 58, 40, 44, 43, 12, 75, 41, 31, 35, 30, 48, 34, 28, 47, 43, 53, 37, 57, 36, 37, 45, 41, 60, 34, 33, 41, 17, 26, 67, 63, 46, 69, 29, 46, 27, 51, 38, 39, 47, 33, 31, 58, 38, 32, 53, 39, 41, 44, 20, 15, 23, 52, 44, 46, 49, 40, 13, 46, 25, 52, 48, 44, 29, 70, 42, 41, 19, 36, 54, 28, 48, 42, 34, 64, 13, 22, 46, 60, 58, 65, 52, 46, 38, 56, 36, 52, 18, 41, 64, 59, 41, 47, 20, 64, 15, 33, 72, 45, 36, 51, 47, 39, 38, 30, 58, 78, 56, 47, 38, 53, 36, 21, 62, 57, 37, 46, 54, 14, 36, 58, 67, 42, 41, 37, 31, 30, 55, 59, 46, 42, 31, 42, 22, 24, 62, 36, 52, 44, 54, 30, 24, 61, 19, 49, 63, 52, 57, 42, 9, 66, 17, 54, 23, 40, 27, 59, 53, 45, 48, 42, 22, 22, 42, 51, 47, 30, 40, 26, 34, 50, 47, 33, 37, 27, 31, 45, 61, 34, 40, 36, 29, 59, 34, 56, 38, 24, 32, 51, 47, 26, 22, 69, 25, 58, 25, 57, 11, 45, 15, 54, 34, 52, 16, 47, 29, 54, 18, 29, 32, 66, 43, 51, 37, 59, 46, 35, 19, 44, 43, 35, 18, 36, 59, 36, 33, 42, 42, 48, 35, 36, 5, 19, 35, 39, 63, 25, 44, 42, 41, 61, 52, 37, 42, 37, 48, 51, 65, 41, 30, 29, 25, 44, 48, 74, 19, 22, 40, 28, 45, 35, 44, 35, 46, 27, 41, 75, 42, 19, 27, 39, 50, 19, 49, 32, 38, 71, 50, 24, 45, 31, 33, 23, 45, 32, 30, 60, 33, 25, 25, 34, 14, 46, 37, 38, 30, 34, 31, 49, 62, 42, 33, 39, 49, 23, 65, 27, 29, 81, 59, 54, 43, 31, 56, 23, 59, 65, 44, 50, 59, 45, 32, 41, 29, 11, 14, 25, 37, 22, 37, 44, 62, 44, 28, 53, 9, 49, 44, 34, 49, 67, 51, 37, 26, 45, 28, 24, 57, 31, 54, 16, 36, 32, 22, 28, 19, 24, 39, 69, 46, 22, 39, 58, 45, 41, 23, 26, 60, 35, 50, 43, 35, 57, 32, 19, 45, 10, 42, 36, 15, 78, 40, 57, 21, 33, 56, 51, 15, 67, 26, 25, 64, 38, 36, 39, 43, 30, 35, 34, 44, 29, 29, 18, 32, 40, 68, 46, 24, 40, 48, 31, 40, 19, 36, 45, 57, 17, 18, 31, 31, 31, 25, 53, 42, 34, 21, 48, 30, 7, 56, 48, 25, 32, 52, 44, 32, 55, 57, 59, 63, 48, 33, 9, 12, 44, 42, 50, 44, 37, 56, 57, 26, 42, 27, 49, 31, 24, 14, 31, 51, 26, 15, 27, 37, 37, 57, 30, 53, 41, 12, 57, 42, 27, 31, 40, 18, 56, 22, 37, 48, 30, 35, 36, 37, 32, 35, 49, 35, 34, 38, 26, 57, 60, 46, 32, 50, 37, 41, 36, 45, 47, 40, 45, 29, 18, 40, 53, 52, 42, 33, 26, 44, 32, 39, 60, 43, 60, 24, 44, 75, 55, 27, 32, 19, 20, 42, 21, 41, 41, 47, 34, 46, 55, 38, 35, 49, 36, 45, 34, 22, 41, 68, 31, 12, 36, 27, 52, 46, 26, 15, 37, 59, 26, 52, 38, 35, 54, 13, 48, 46, 55, 57, 39, 52, 35, 44, 52, 24, 51, 41, 59, 53, 36, 38, 62, 44, 58, 18, 41, 44, 44, 26, 38, 35, 42, 49, 52, 37, 33, 46, 56, 42, 44, 47, 63, 24, 47, 69, 31, 32, 11, 23, 46, 43, 53, 65, 56, 17, 54, 29, 36, 38, 54, 33, 37, 53, 46, 30, 46, 28, 30, 41, 31, 23, 49, 35, 33, 62, 43, 44, 30, 18, 52, 57, 38, 42, 30, 42, 44, 44, 39, 46, 50, 44, 27, 61, 29, 31, 33, 41, 68, 49, 36, 13, 32, 62, 41, 59, 39, 24, 12, 57, 53, 31, 66, 19, 47, 47, 51, 60, 21, 41, 50, 49, 31, 26, 64, 26, 48, 29, 4, 35, 48, 51, 52, 33, 23, 26, 60, 44, 55, 23, 44, 41, 47, 52, 26, 13, 75, 12, 53, 43, 54, 40, 57, 36, 17, 33, 49, 25, 54, 10, 34, 43, 28, 37, 48, 31, 25, 54, 22, 70, 55, 39, 57, 39, 14, 39, 20, 57, 39, 35, 42, 40, 35, 30, 70, 24, 43, 42, 28, 43, 13, 32, 19, 42, 53, 63, 31, 44, 19, 41, 29, 51, 30, 61, 45, 43, 47, 65, 56, 53, 23, 27, 54, 39, 56, 47, 50, 54, 49, 51, 15, 35, 32, 68, 41, 76, 16, 43, 36, 23, 40, 43, 12, 30, 56, 57, 47, 18, 31, 53, 22, 47, 21, 39, 47, 43, 29, 51, 29, 39, 36, 54, 24, 30, 62, 36, 70, 16, 46, 24, 15, 26, 20, 42, 55, 29, 57, 59, 30, 47, 60, 37, 43, 43, 27, 42, 55, 26, 12, 16, 45, 42, 57, 39, 22, 37, 38, 41, 38, 46, 22, 10, 51, 32, 38, 41, 17, 17, 28, 35, 43, 25, 51, 35, 45, 67, 42, 18, 41, 35, 77, 30, 20, 46, 46, 43, 44, 41, 50, 29, 45, 26, 31, 41, 32, 44, 31, 58, 26, 30, 66, 14, 55, 30, 19, 48, 55, 53, 15, 64, 32, 43, 21, 40, 78, 37, 29, 46, 29, 25, 40, 67, 32, 53, 29, 48, 28, 48, 26, 70, 53, 52, 47, 19, 22, 44, 49, 48, 29, 55, 44, 30, 55, 32, 50, 51, 45, 63, 71, 28, 13, 26, 48, 34, 43, 49, 39, 38, 69, 14, 32, 38, 50, 48, 37, 50, 33, 52, 28, 39, 46, 37, 30, 28, 28, 32, 35, 24, 38, 33, 36, 52, 37, 27, 32, 15, 41, 36, 53, 23, 33, 11, 43, 48, 32, 50, 35, 69, 31, 39, 10, 22, 18, 40, 21, 8, 39, 39, 32, 28, 35, 61, 47, 28, 41, 61, 71, 39, 37, 42, 55, 46, 23, 42, 64, 28, 33, 22, 65, 26, 35, 26, 23, 22, 53, 51, 50, 22, 50, 49, 28, 15, 48, 58, 53, 51, 44, 25, 26, 59, 47, 51, 25, 21, 40, 32, 26, 35, 68, 34, 17, 59, 63, 29, 22, 27, 8, 21, 49, 43, 46, 28, 53, 43, 16, 58, 56, 56, 38, 41, 53, 51, 58, 50, 52, 31, 44, 26, 36, 52, 38, 14, 31, 40, 24, 52, 58, 37, 56, 43, 62, 58, 25, 55, 30, 40, 60, 26, 23, 26, 61, 18, 43, 43, 47, 21, 38, 51, 33, 60, 39, 40, 40, 58, 38, 43, 31, 49, 28, 20, 48, 36, 42, 28, 36, 22, 62, 19, 52, 28, 47, 51, 58, 56, 32, 29, 75, 55, 32, 40, 34, 47, 57, 49, 32, 41, 20, 25, 38, 42, 30, 53, 24, 25, 53, 42, 17, 29, 21, 44, 46, 33, 32, 54, 35, 48, 30, 66, 43, 44, 71, 66, 46, 57, 64, 9, 41, 22, 39, 45, 43, 33, 26, 46, 41, 34, 32, 66, 18, 40, 22, 52, 29, 73, 31, 36, 36, 50, 26, 56, 62, 19, 76, 43, 39, 55, 39, 44, 58, 15, 27, 16, 47, 35, 50, 23, 58, 57, 44, 53, 48, 24, 63, 20, 39, 40, 39, 30, 38, 32, 44, 29, 43, 30, 49, 45, 45, 42, 69, 16, 26, 57, 36, 37, 56, 47, 15, 57, 64, 36, 50, 42, 39, 9, 45, 14, 36, 33, 34, 47, 32, 52, 26, 41, 33, 19, 43, 15, 25, 55, 59, 33, 33, 32, 44, 56, 67, 84, 33, 42, 44, 61, 47, 24, 71, 29, 22, 36, 33, 41, 19, 36, 24, 51, 36, 29, 26, 26, 35, 28, 38, 49, 58, 35, 47, 31, 43, 30, 23, 19, 29, 33, 50, 44, 71, 13, 20, 22, 31, 44, 62, 23, 25, 31, 24, 48, 25, 58, 32, 31, 37, 34, 63, 56, 16, 59, 51, 25, 30, 69, 32, 39, 50, 55, 28, 37, 87, 35, 70, 52, 33, 41, 47, 9, 52, 55, 32, 59, 47, 79, 35, 55, 12, 25, 24, 36, 18, 52, 34, 28, 56, 20, 35, 24, 40, 61, 42, 61, 29, 29, 30, 64, 45, 22, 45, 28, 45, 30, 46, 47, 33, 25, 34, 43, 53, 41, 20, 43, 60, 49, 46, 55, 50, 32, 45, 33, 62, 14, 57, 54, 35, 26, 58, 36, 52, 68, 29, 56, 30, 13, 38, 22, 30, 33, 52, 35, 63, 42, 50, 44, 23, 52, 37, 17, 56, 49, 44, 50, 50, 48, 37, 52, 35, 43, 46, 12, 52, 45, 34, 36, 22, 46, 51, 50, 33, 34, 35, 25, 28, 71, 33, 34, 10, 19, 20, 42, 39, 73, 37, 39, 30, 43, 40, 15, 55, 35, 32, 49, 51, 41, 55, 42, 44, 46, 20, 44, 61, 46, 55, 34, 27, 32, 33, 41, 56, 33, 63, 7, 34, 7, 36, 36, 50, 15, 30, 45, 29, 39, 62, 30, 66, 37, 40, 61, 35, 25, 64, 20, 38, 29, 17, 23, 41, 42, 50, 49, 45, 27, 28, 46, 69, 24, 57, 34, 43, 22, 34, 19, 30, 21, 11, 62, 47, 44, 50, 37, 39, 32, 33, 10, 56, 39, 17, 35, 57, 42, 55, 41, 30, 38, 27, 44, 28, 31, 36, 52, 17, 12, 37, 47, 48, 20, 55, 47, 38, 62, 48, 41, 48, 46, 22, 59, 37, 39, 30, 39, 32, 19, 51, 33, 61, 52, 46, 47, 34, 32, 44, 41, 42, 64, 23, 31, 48, 62, 19, 50, 34, 40, 21, 43, 19, 31, 57, 37, 52, 69, 49, 45, 28, 35, 23, 21, 35, 27, 41, 58, 8, 20, 41, 37, 46, 26, 45, 21, 39, 54, 21, 41, 41, 26, 58, 16, 69, 49, 26, 30, 32, 63, 51, 30, 74, 42, 36, 46, 31, 54, 24, 27, 21, 62, 30, 41, 34, 62, 59, 21, 40, 22, 29, 69, 31, 17, 36, 44, 36, 65, 49, 52, 52, 22, 51, 35, 55, 28, 43, 28, 45, 28, 48, 49, 47, 41, 34, 60, 28, 45, 32, 77, 44, 36, 25, 58, 17, 50, 51, 39, 40, 9, 52, 21, 15, 41, 34, 49, 57, 28, 21, 47, 26, 68, 47, 13, 54, 49, 26, 63, 34, 52, 35, 28, 7, 46, 63, 17, 20, 32, 27, 42, 17, 55, 50, 14, 33, 45, 36, 15, 10, 46, 25, 41, 49, 67, 20, 27, 49, 28, 36, 68, 37, 34, 59, 44, 55, 34, 69, 51, 56, 36, 30, 63, 60, 84, 48, 44, 44, 47, 34, 58, 45, 39, 23, 33, 39, 85, 64, 56, 42, 46, 43, 35, 32, 55, 28, 46, 23, 58, 28, 31, 54, 52, 31, 48, 35, 50, 24, 35, 54, 13, 10, 23, 51, 38, 24, 53, 3, 18, 34, 55, 54, 23, 42, 54, 12, 36, 50, 39, 43, 29, 38, 36, 41, 40, 36, 32, 29, 46, 37, 69, 36, 36, 50, 40, 28, 21, 45, 42, 16, 49, 50, 36, 37, 24, 30, 32, 29, 36, 20, 57, 16, 25, 53, 49, 23, 51, 40, 22, 59, 32, 45, 40, 31, 44, 39, 26, 29, 38, 60, 41, 71, 39, 37, 20, 26, 39, 32, 40, 45, 43, 67, 32, 45, 53, 29, 54, 36, 41, 33, 24, 57, 51, 55, 40, 64, 25, 27, 20, 18, 31, 43, 18, 24, 30, 25, 48, 53, 18, 39, 37, 54, 25, 35, 31, 35, 34, 30, 44, 12, 45, 31, 44, 38, 17, 50, 31, 31, 37, 42, 43, 33, 35, 22, 26, 48, 47, 33, 58, 29, 53, 31, 27, 66, 6, 60, 46, 36, 27, 66, 54, 57, 71, 5, 12, 42, 42, 15, 28, 43, 71, 21, 53, 48, 33, 27, 55, 14, 51, 34, 17, 53, 30, 32, 37, 59, 39, 29, 64, 50, 48, 51, 32, 28, 29, 32, 49, 18, 58, 49, 46, 35, 50, 40, 48, 33, 27, 35, 51, 38, 51, 57, 14, 78, 34, 18, 33, 33, 35, 45, 34, 40, 12, 25, 53, 56, 27, 31, 40, 27, 48, 68, 48, 29, 42, 19, 38, 53, 33, 19, 54, 17, 27, 42, 69, 60, 37, 65, 57, 55, 65, 48, 42, 76, 23, 26, 64, 52, 55, 6, 27, 26, 29, 30, 26, 64, 50, 59, 54, 58, 34, 47, 42, 50, 55, 53, 24, 28, 21, 51, 39, 56, 37, 49, 37, 56, 37, 58, 49, 39, 61, 40, 41, 19, 50, 65, 50, 53, 45, 54, 20, 30, 29, 27, 53, 37, 56, 24, 37, 54, 46, 18, 11, 43, 19, 34, 22, 27, 29, 35, 48, 56, 48, 53, 27, 38, 39, 26, 33, 15, 62, 28, 56, 43, 31, 15, 45, 50, 23, 49, 27, 57, 25, 36, 32, 54, 60, 38, 33, 28, 32, 49, 34, 14, 27, 58, 20, 21, 23, 43, 38, 29, 52, 78, 41, 63, 50, 38, 36, 39, 65, 36, 38, 61, 59, 47, 45, 17, 57, 24, 69, 74, 23, 50, 32, 35, 55, 42, 54, 47, 29, 52, 42, 27, 12, 60, 11, 33, 28, 48, 38, 25, 45, 59, 28, 61, 42, 33, 29, 27, 64, 20, 27, 15, 56, 15, 64, 34, 41, 27, 77, 52, 51, 36, 40, 43, 59, 23, 19, 49, 44, 47, 45, 37, 38, 39, 31, 35, 41, 18, 55, 38, 60, 38, 20, 52, 21, 26, 49, 73, 35, 29, 32, 29, 17, 47, 31, 38, 36, 31, 33, 22, 14, 17, 44, 72, 54, 58, 32, 49, 29, 28, 50, 62, 42, 35, 30, 22, 35, 29, 40, 43, 42, 50, 33, 42, 61, 42, 40, 34, 44, 30, 15, 64, 48, 35, 25, 44, 41, 53, 26, 46, 61, 38, 20, 39, 63, 24, 34, 52, 17, 30, 41, 45, 40, 55, 56, 27, 44, 31, 23, 24, 52, 39, 24, 51, 46, 60, 27, 52, 34, 62, 22, 48, 58, 38, 39, 60, 72, 24, 51, 51, 12, 48, 7, 20, 19, 46, 27, 45, 21, 31, 34, 35, 50, 6, 40, 45, 47, 42, 37, 24, 66, 43, 39, 40, 64, 30, 48, 9, 47, 47, 59, 40, 34, 46, 33, 45, 44, 49, 34, 56, 48, 31, 39, 58, 62, 30, 24, 42, 28, 59, 57, 61, 38, 60, 35, 23, 46, 46, 40, 44, 43, 38, 34, 51, 49, 49, 39, 37, 21, 74, 48, 80, 39, 30, 23, 53, 48, 42, 20, 44, 35, 53, 34, 52, 14, 32, 73, 36, 24, 41, 42, 46, 39, 35, 40, 18, 14, 34, 27, 38, 54, 28, 29, 41, 71, 18, 48, 41, 32, 34, 13, 37, 24, 23, 38, 47, 42, 47, 53, 38, 31, 9, 37, 59, 33, 29, 67, 9, 27, 44, 53, 13, 29, 38, 52, 32, 31, 22, 54, 43, 42, 20, 32, 43, 17, 60, 17, 38, 40, 25, 67, 50, 40, 16, 72, 41, 43, 12, 47, 10, 34, 31, 28, 43, 63, 55, 42, 17, 31, 62, 53, 19, 22, 28, 46, 42, 29, 76, 17, 21, 41, 31, 32, 42, 43, 43, 24, 36, 59, 5, 60, 37, 18, 46, 9, 48, 53, 51, 60, 40, 21, 9, 19, 38, 44, 32, 41, 30, 43, 52, 26, 20, 46, 37, 40, 54, 40, 36, 10, 29, 54, 56, 19, 35, 59, 33, 42, 39, 32, 50, 31, 33, 57, 15, 32, 34, 41, 55, 43, 55, 59, 41, 69, 32, 34, 21, 34, 32, 43, 55, 27, 28, 49, 22, 34, 37, 36, 39, 58, 42, 45, 50, 14, 39, 56, 46, 73, 21, 29, 37, 34, 56, 55, 37, 44, 49, 40, 51, 64, 64, 62, 60, 10, 43, 34, 43, 20, 31, 44, 41, 40, 29, 57, 68, 47, 44, 28, 27, 34, 53, 49, 48, 38, 51, 25, 15, 31, 28, 42, 50, 37, 33, 38, 24, 36, 29, 38, 65, 48, 60, 40, 40, 42, 10, 36, 36, 46, 64, 45, 38, 51, 20, 45, 39, 38, 44, 12, 61, 27, 44, 62, 50, 69, 57, 58, 53, 31, 56, 29, 39, 21, 35, 40, 29, 36, 28, 56, 15, 55, 59, 50, 46, 8, 38, 54, 15, 46, 29, 59, 56, 52, 33, 34, 74, 34, 38, 43, 25, 37, 42, 40, 64, 58, 31, 28, 47, 21, 60, 54, 62, 70, 27, 44, 17, 25, 35, 7, 58, 6, 68, 39, 37, 4, 44, 30, 41, 12, 42, 24, 31, 24, 58, 48, 37, 38, 44, 43, 45, 42, 31, 17, 41, 52, 55, 45, 24, 5, 56, 73, 25, 30, 36, 59, 24, 46, 18, 57, 30, 31, 34, 40, 61, 46, 49, 40, 44, 45, 20, 43, 33, 42, 38, 54, 10, 39, 42, 40, 12, 48, 36, 32, 33, 43, 38, 28, 28, 18, 61, 27, 23, 37, 51, 31, 30, 46, 22, 32, 27, 36, 44, 79, 45, 50, 44, 6, 33, 28, 31, 15, 36, 54, 43, 51, 51, 21, 57, 21, 24, 17, 53, 38, 41, 37, 18, 21, 27, 43, 42, 20, 18, 55, 21, 36, 43, 26, 38, 46, 44, 50, 27, 19, 45, 45, 39, 25, 56, 27, 45, 55, 36, 37, 30, 30, 27, 38, 44, 52, 30, 48, 42, 29, 27, 24, 14, 38, 18, 38, 52, 36, 17, 37, 53, 59, 61, 12, 27, 36, 24, 16, 22, 31, 55, 45, 54, 45, 51, 29, 32, 33, 46, 30, 49, 51, 47, 71, 52, 33, 12, 36, 39, 33, 53, 43, 32, 76, 39, 25, 31, 28, 14, 40, 70, 35, 30, 51, 44, 47, 39, 48, 43, 33, 37, 12, 34, 62, 46, 36, 44, 25, 69, 36, 24, 13, 34, 45, 28, 47, 27, 58, 14, 36, 45, 36, 35, 20, 55, 14, 29, 50, 50, 33, 28, 24, 38, 26, 68, 55, 20, 33, 47, 56, 67, 48, 39, 37, 50, 51, 29, 20, 34, 33, 53, 45, 28, 51, 50, 39, 53, 50, 58, 46, 43, 16, 31, 50, 71, 40, 41, 66, 40, 33, 38, 48, 52, 11, 28, 29, 49, 56, 23, 46, 51, 58, 49, 33, 47, 28, 41, 51, 25, 45, 41, 28, 39, 54, 41, 28, 26, 35, 33, 56, 45, 39, 27, 40, 48, 25, 40, 51, 51, 33, 32, 41, 10, 41, 55, 43, 26, 28, 50, 46, 29, 35, 19, 27, 28, 55, 36, 57, 64, 44, 34, 34, 32, 26, 30, 36, 20, 40, 6, 37, 33, 49, 68, 45, 34, 54, 52, 48, 65, 37, 35, 32, 48, 41, 48, 32, 43, 26, 41, 35, 41, 62, 35, 26, 45, 31, 30, 37, 23, 68, 40, 16, 28, 28, 24, 39, 46, 12, 40, 45, 44, 35, 53, 38, 42, 27, 32, 39, 53, 18, 30, 45, 58, 42, 36, 67, 24, 36, 38, 9, 56, 61, 47, 60, 58, 66, 14, 35, 32, 32, 58, 38, 40, 37, 38, 44, 57, 34, 75, 44, 33, 29, 53, 44, 32, 40, 35, 55, 13, 35, 52, 31, 47, 16, 35, 56, 39, 33, 46, 47, 24, 46, 21, 35, 35, 17, 31, 39, 39, 36, 17, 29, 42, 33, 29, 54, 56, 24, 28, 48, 15, 44, 35, 35, 39, 60, 42, 48, 43, 58, 36, 46, 30, 45, 40, 63, 42, 15, 54, 34, 30, 54, 34, 21, 19, 25, 21, 19, 47, 28, 58, 28, 11, 29, 36, 30, 56, 31, 38, 29, 48, 36, 34, 45, 35, 39, 55, 10, 31, 72, 44, 31, 44, 34, 15, 39, 5, 35, 35, 50, 66, 45, 50, 47, 40, 20, 22, 50, 34, 46, 55, 44, 55, 62, 38, 46, 45, 52, 27, 51, 33, 29, 16, 40, 37, 62, 37, 46, 26, 37, 47, 26, 39, 36, 35, 31, 48, 19, 41, 56, 44, 54, 67, 36, 27, 39, 31, 46, 19, 50, 29, 48, 28, 52, 49, 30, 39, 53, 54, 20, 29, 48, 40, 44, 49, 53, 19, 23, 33, 32, 47, 36, 42, 38, 24, 13, 52, 45, 52, 46, 59, 18, 31, 37, 35, 22, 26, 9, 12, 20, 36, 10, 41, 31, 48, 42, 44, 29, 38, 53, 27, 50, 46, 64, 22, 30, 37, 24, 50, 52, 32, 43, 51, 78, 70, 62, 34, 58, 27, 61, 27, 54, 59, 48, 42, 58, 67, 50, 24, 42, 30, 29, 36, 52, 53, 27, 20, 38, 9, 29, 17, 34, 26, 8, 32, 52, 27, 31, 35, 31, 23, 50, 24, 41, 67, 44, 69, 21, 30, 58, 33, 32, 44, 53, 41, 41, 40, 15, 48, 56, 39, 37, 59, 20, 61, 38, 44, 23, 28, 32, 54, 29, 33, 46, 42, 63, 58, 47, 37, 32, 12, 39, 46, 13, 56, 68, 49, 59, 35, 23, 13, 47, 27, 69, 4, 49, 35, 60, 41, 5, 28, 67, 51, 42, 45, 28, 36, 42, 52, 50, 46, 36, 35, 17, 33, 20, 23, 53, 38, 39, 43, 29, 37, 55, 44, 32, 35, 20, 63, 51, 39, 50, 30, 27, 80, 18, 53, 54, 51, 53, 39, 32, 63, 10, 31, 32, 39, 38, 44, 30, 37, 40, 44, 43, 30, 20, 44, 58, 70, 65, 54, 47, 40, 54, 36, 46, 48, 54, 31, 29, 47, 48, 27, 46, 24, 40, 50, 28, 50, 31, 19, 50, 61, 37, 36, 47, 25, 67, 31, 38, 19, 39, 25, 14, 76, 34, 52, 22, 55, 47, 20, 39, 34, 54, 40, 44, 59, 48, 41, 50, 29, 25, 42, 64, 38, 23, 55, 27, 40, 47, 24, 34, 66, 31, 56, 10, 46, 43, 45, 30, 48, 15, 28, 43, 50, 16, 35, 28, 45, 40, 38, 48, 16, 26, 30, 26, 30, 68, 67, 53, 44, 45, 51, 47, 45, 29, 45, 46, 46, 75, 21, 28, 30, 35, 44, 45, 42, 48, 33, 52, 49, 53, 39, 36, 25, 49, 45, 17, 20, 61, 18, 29, 68, 50, 47, 28, 41, 26, 36, 40, 16, 46, 26, 38, 37, 59, 56, 18, 57, 33, 65, 44, 42, 37, 55, 38, 46, 8, 16, 51, 27, 51, 54, 27, 12, 10, 48, 70, 19, 39, 39, 28, 36, 23, 33, 32, 31, 24, 7, 37, 21, 31, 36, 46, 21, 51, 61, 54, 24, 36, 74, 40, 49, 25, 40, 46, 19, 28, 44, 58, 10, 34, 43, 45, 30, 36, 48, 33, 50, 43, 50, 35, 16, 40, 36, 38, 35, 54, 37, 40, 42, 14, 35, 41, 47, 51, 50, 61, 36, 58, 30, 46, 44, 38, 20, 11, 34, 42, 59, 38, 71, 40, 25, 35, 52, 26, 66, 49, 36, 31, 24, 52, 58, 60, 7, 31, 49, 35, 61, 56, 46, 32, 19, 78, 35]}, 'test_3': {'capacity': 100, 'num_items': 5000, 'items': [55, 51, 16, 43, 30, 49, 52, 44, 48, 29, 52, 34, 37, 25, 53, 48, 33, 34, 37, 72, 42, 46, 13, 64, 42, 66, 60, 37, 27, 48, 32, 46, 41, 36, 52, 22, 17, 30, 32, 37, 39, 35, 43, 55, 49, 23, 43, 66, 36, 42, 30, 37, 29, 44, 29, 48, 51, 47, 60, 51, 40, 36, 55, 60, 42, 60, 54, 20, 28, 43, 46, 41, 39, 36, 22, 23, 22, 44, 44, 41, 35, 50, 17, 30, 24, 46, 32, 66, 39, 54, 34, 24, 41, 49, 37, 41, 5, 34, 49, 44, 24, 44, 20, 31, 46, 32, 86, 31, 48, 38, 49, 16, 46, 58, 18, 41, 26, 61, 48, 51, 16, 48, 30, 48, 21, 34, 13, 37, 59, 30, 34, 68, 59, 36, 28, 19, 61, 50, 14, 44, 43, 18, 48, 69, 55, 63, 69, 69, 25, 55, 44, 55, 29, 63, 50, 47, 37, 40, 35, 25, 25, 34, 49, 30, 40, 34, 47, 43, 65, 69, 47, 67, 36, 56, 18, 16, 34, 48, 31, 13, 61, 42, 24, 52, 42, 35, 37, 33, 17, 21, 49, 57, 47, 27, 25, 52, 20, 20, 36, 40, 46, 44, 59, 46, 47, 54, 38, 65, 68, 54, 47, 36, 61, 25, 53, 34, 21, 54, 61, 27, 31, 50, 42, 43, 25, 29, 32, 26, 26, 37, 33, 29, 30, 64, 37, 52, 43, 43, 47, 59, 37, 38, 33, 66, 34, 32, 53, 14, 67, 10, 35, 58, 50, 23, 36, 46, 52, 34, 48, 24, 28, 47, 49, 19, 60, 20, 23, 18, 34, 32, 62, 31, 50, 53, 26, 53, 27, 39, 40, 61, 48, 41, 40, 32, 33, 42, 30, 31, 50, 19, 36, 64, 46, 36, 29, 55, 49, 43, 42, 62, 47, 36, 49, 47, 27, 59, 24, 46, 40, 48, 35, 39, 62, 31, 67, 37, 15, 10, 17, 66, 48, 35, 24, 36, 41, 17, 34, 43, 70, 44, 55, 50, 35, 42, 14, 33, 63, 12, 62, 56, 60, 17, 26, 45, 62, 68, 24, 66, 24, 52, 27, 12, 68, 43, 41, 38, 75, 65, 51, 63, 20, 24, 32, 46, 41, 32, 51, 64, 60, 11, 59, 54, 47, 60, 26, 38, 76, 15, 46, 7, 25, 57, 23, 32, 34, 26, 25, 38, 59, 45, 38, 33, 31, 37, 37, 44, 46, 21, 22, 52, 29, 19, 39, 41, 39, 31, 51, 32, 23, 21, 30, 49, 64, 28, 49, 19, 48, 19, 49, 16, 34, 46, 61, 13, 45, 39, 36, 36, 32, 40, 29, 54, 34, 37, 38, 65, 27, 28, 38, 46, 34, 38, 50, 54, 34, 39, 39, 21, 38, 44, 21, 52, 59, 33, 69, 38, 54, 13, 44, 52, 32, 28, 44, 43, 58, 21, 52, 35, 42, 34, 49, 39, 26, 69, 25, 37, 49, 54, 56, 65, 43, 32, 36, 27, 40, 23, 48, 24, 13, 25, 38, 29, 40, 26, 36, 50, 47, 25, 59, 24, 45, 28, 41, 23, 55, 44, 49, 64, 14, 49, 13, 12, 14, 61, 37, 63, 45, 17, 33, 27, 32, 15, 48, 54, 28, 36, 24, 45, 43, 26, 55, 29, 60, 53, 30, 87, 48, 51, 47, 54, 38, 53, 51, 25, 48, 12, 30, 36, 80, 63, 30, 33, 38, 33, 32, 24, 12, 29, 41, 26, 64, 37, 24, 83, 27, 62, 52, 45, 23, 39, 37, 51, 52, 48, 23, 34, 51, 27, 41, 50, 52, 73, 23, 38, 38, 25, 36, 52, 79, 21, 42, 60, 68, 48, 23, 15, 33, 39, 50, 23, 39, 64, 51, 16, 27, 41, 70, 50, 34, 29, 44, 18, 63, 47, 14, 36, 45, 69, 71, 42, 11, 49, 10, 43, 31, 48, 54, 31, 40, 35, 40, 38, 33, 46, 43, 34, 26, 49, 8, 46, 11, 27, 27, 11, 64, 47, 37, 41, 68, 28, 31, 69, 36, 40, 45, 49, 55, 35, 46, 44, 66, 50, 53, 37, 30, 66, 14, 63, 39, 45, 42, 37, 48, 55, 54, 32, 18, 64, 39, 49, 68, 35, 40, 16, 51, 51, 41, 54, 41, 27, 17, 40, 36, 54, 58, 36, 46, 29, 34, 35, 18, 41, 59, 49, 44, 36, 50, 29, 36, 15, 58, 30, 15, 46, 26, 30, 62, 50, 35, 19, 35, 20, 32, 19, 69, 19, 40, 51, 51, 53, 17, 38, 40, 10, 43, 22, 72, 33, 70, 14, 48, 38, 50, 42, 21, 28, 36, 44, 67, 34, 22, 17, 18, 28, 49, 66, 26, 53, 41, 21, 8, 26, 39, 54, 45, 42, 28, 49, 62, 66, 41, 36, 41, 32, 31, 20, 42, 26, 39, 37, 29, 29, 21, 41, 26, 36, 57, 44, 45, 26, 42, 44, 45, 47, 61, 51, 27, 22, 44, 44, 25, 7, 36, 21, 53, 26, 38, 26, 28, 60, 57, 28, 65, 64, 33, 34, 29, 26, 48, 42, 46, 21, 31, 62, 58, 47, 56, 42, 50, 52, 41, 23, 28, 64, 11, 46, 36, 56, 44, 58, 58, 29, 13, 68, 46, 45, 15, 29, 53, 51, 58, 27, 35, 47, 39, 48, 34, 26, 36, 54, 60, 56, 67, 40, 39, 63, 47, 44, 24, 58, 48, 48, 49, 46, 41, 68, 42, 50, 73, 23, 23, 36, 41, 43, 20, 63, 36, 20, 39, 49, 25, 32, 53, 21, 31, 54, 30, 22, 28, 37, 57, 37, 41, 42, 21, 14, 48, 22, 49, 39, 21, 36, 19, 31, 64, 50, 12, 32, 58, 45, 35, 21, 49, 58, 69, 48, 37, 27, 44, 32, 20, 24, 35, 49, 54, 19, 53, 40, 49, 67, 26, 49, 70, 43, 30, 38, 27, 35, 57, 39, 45, 38, 41, 15, 21, 54, 26, 34, 46, 64, 36, 28, 45, 63, 57, 67, 22, 26, 8, 42, 47, 36, 66, 23, 42, 24, 16, 37, 39, 57, 54, 26, 33, 17, 21, 66, 26, 32, 35, 54, 40, 19, 59, 41, 45, 34, 45, 31, 32, 20, 35, 50, 24, 41, 93, 47, 30, 45, 32, 45, 37, 40, 67, 32, 14, 28, 41, 62, 34, 28, 33, 28, 41, 61, 37, 46, 23, 32, 33, 39, 37, 49, 36, 32, 61, 27, 68, 62, 52, 40, 39, 46, 23, 49, 17, 38, 31, 23, 17, 25, 70, 47, 46, 50, 15, 34, 56, 51, 48, 74, 27, 64, 11, 51, 46, 37, 35, 51, 23, 35, 36, 31, 55, 32, 33, 49, 12, 39, 48, 20, 35, 58, 70, 36, 52, 21, 46, 32, 41, 42, 42, 13, 14, 44, 31, 51, 47, 21, 45, 43, 38, 44, 44, 32, 54, 30, 51, 36, 8, 44, 14, 28, 35, 34, 40, 28, 16, 49, 21, 33, 39, 48, 65, 38, 58, 38, 35, 41, 36, 77, 33, 38, 29, 23, 20, 59, 38, 30, 32, 25, 27, 28, 45, 43, 42, 23, 20, 37, 29, 49, 51, 10, 73, 12, 33, 30, 21, 48, 38, 48, 46, 31, 37, 35, 26, 67, 21, 66, 55, 43, 26, 49, 52, 39, 33, 59, 33, 25, 54, 55, 16, 19, 34, 49, 42, 44, 26, 32, 40, 25, 53, 33, 36, 61, 66, 55, 78, 54, 31, 44, 40, 25, 31, 65, 57, 50, 25, 17, 52, 23, 50, 24, 54, 28, 56, 26, 41, 46, 43, 43, 46, 39, 26, 26, 40, 59, 31, 24, 30, 14, 53, 34, 54, 34, 46, 66, 51, 52, 56, 30, 45, 38, 22, 49, 55, 40, 24, 54, 41, 44, 38, 39, 40, 15, 7, 76, 42, 53, 44, 39, 39, 41, 38, 53, 23, 52, 44, 28, 62, 41, 69, 43, 60, 37, 33, 37, 69, 38, 49, 35, 37, 29, 22, 37, 52, 40, 40, 20, 18, 30, 39, 49, 10, 9, 62, 47, 46, 27, 79, 43, 37, 34, 57, 56, 45, 42, 44, 47, 21, 27, 59, 36, 17, 39, 45, 69, 28, 28, 48, 20, 47, 48, 60, 31, 56, 43, 54, 19, 19, 59, 67, 23, 48, 52, 26, 50, 18, 70, 22, 15, 42, 39, 29, 64, 23, 57, 24, 31, 12, 25, 20, 54, 49, 65, 60, 41, 32, 45, 41, 57, 54, 35, 16, 27, 54, 55, 71, 33, 21, 51, 39, 45, 29, 36, 28, 7, 8, 34, 38, 26, 33, 81, 62, 15, 31, 19, 42, 25, 47, 53, 45, 49, 52, 33, 42, 34, 59, 54, 45, 54, 31, 47, 52, 42, 26, 46, 36, 41, 54, 31, 52, 60, 42, 41, 47, 43, 19, 54, 17, 31, 34, 77, 49, 12, 27, 36, 61, 31, 47, 45, 53, 48, 44, 18, 45, 51, 21, 32, 20, 38, 32, 15, 35, 45, 34, 38, 35, 48, 60, 61, 37, 54, 26, 74, 56, 22, 38, 20, 24, 42, 26, 48, 58, 61, 45, 40, 48, 50, 25, 36, 67, 44, 52, 30, 69, 35, 39, 46, 65, 76, 41, 45, 28, 34, 41, 27, 61, 51, 18, 34, 45, 20, 29, 54, 27, 32, 65, 16, 27, 47, 25, 17, 38, 38, 35, 34, 22, 34, 36, 15, 49, 47, 78, 20, 28, 26, 42, 34, 32, 38, 42, 50, 32, 47, 37, 32, 52, 39, 30, 29, 58, 27, 25, 38, 50, 49, 39, 50, 43, 27, 55, 49, 49, 58, 31, 18, 41, 49, 49, 31, 12, 41, 68, 51, 83, 22, 38, 39, 65, 35, 17, 49, 28, 21, 19, 53, 40, 44, 67, 49, 17, 25, 31, 24, 29, 41, 26, 35, 38, 36, 61, 38, 37, 13, 49, 58, 37, 32, 57, 46, 39, 38, 25, 47, 17, 50, 33, 51, 44, 47, 47, 35, 42, 47, 50, 31, 46, 11, 28, 52, 22, 31, 50, 54, 22, 39, 36, 29, 34, 34, 60, 47, 29, 40, 49, 26, 51, 26, 52, 39, 49, 14, 52, 19, 34, 48, 39, 14, 57, 40, 49, 16, 68, 45, 30, 29, 55, 40, 42, 43, 33, 61, 38, 40, 23, 9, 47, 59, 38, 38, 39, 30, 59, 45, 81, 48, 62, 22, 40, 20, 46, 19, 62, 56, 40, 34, 35, 34, 26, 40, 34, 26, 48, 37, 22, 45, 26, 38, 13, 21, 37, 37, 31, 56, 47, 17, 42, 12, 35, 58, 29, 40, 39, 34, 25, 50, 49, 10, 58, 62, 28, 84, 47, 41, 48, 62, 54, 49, 53, 58, 33, 52, 43, 27, 29, 53, 81, 52, 31, 23, 37, 50, 68, 28, 30, 14, 39, 55, 44, 40, 37, 28, 31, 42, 40, 51, 45, 58, 67, 36, 39, 34, 26, 61, 49, 57, 51, 42, 26, 63, 46, 41, 58, 13, 49, 39, 43, 49, 23, 43, 51, 51, 20, 47, 15, 55, 72, 18, 21, 25, 37, 49, 39, 45, 52, 39, 73, 31, 38, 36, 36, 29, 33, 33, 21, 22, 36, 41, 65, 69, 28, 28, 26, 59, 26, 41, 35, 14, 22, 44, 43, 40, 34, 54, 29, 36, 50, 37, 44, 48, 26, 44, 64, 32, 48, 46, 50, 37, 45, 40, 11, 31, 14, 32, 42, 40, 36, 34, 36, 48, 29, 16, 48, 55, 54, 58, 32, 35, 55, 28, 43, 24, 38, 52, 34, 34, 20, 63, 31, 57, 38, 31, 27, 51, 34, 18, 60, 47, 55, 39, 41, 39, 27, 39, 67, 57, 41, 21, 13, 39, 42, 28, 33, 32, 31, 57, 18, 50, 32, 16, 42, 44, 15, 31, 51, 48, 15, 22, 40, 29, 26, 14, 51, 38, 39, 40, 21, 52, 59, 23, 38, 26, 45, 32, 61, 40, 51, 35, 44, 53, 38, 49, 29, 26, 21, 37, 20, 54, 29, 56, 28, 75, 29, 47, 59, 36, 24, 31, 32, 51, 43, 45, 72, 44, 30, 62, 39, 30, 36, 37, 33, 31, 32, 39, 30, 64, 46, 25, 22, 70, 45, 30, 62, 67, 61, 40, 9, 41, 5, 30, 52, 32, 38, 8, 13, 67, 27, 40, 36, 36, 38, 31, 27, 39, 33, 72, 56, 41, 64, 51, 62, 21, 36, 51, 30, 36, 29, 33, 17, 43, 18, 38, 24, 59, 30, 36, 15, 27, 45, 14, 47, 29, 36, 51, 58, 45, 49, 61, 37, 45, 38, 58, 30, 58, 52, 29, 65, 38, 43, 18, 30, 28, 41, 42, 11, 51, 22, 57, 38, 54, 36, 55, 38, 29, 46, 35, 27, 26, 56, 47, 27, 29, 22, 38, 13, 24, 32, 42, 32, 50, 46, 35, 24, 41, 54, 43, 47, 36, 37, 30, 48, 34, 55, 38, 35, 75, 28, 12, 57, 39, 21, 18, 33, 17, 26, 48, 68, 55, 50, 50, 30, 45, 26, 37, 52, 53, 22, 73, 54, 39, 24, 26, 27, 23, 38, 41, 48, 47, 30, 36, 22, 38, 27, 26, 33, 58, 70, 68, 8, 29, 9, 19, 17, 32, 42, 50, 60, 43, 51, 25, 30, 56, 22, 70, 52, 26, 22, 53, 47, 23, 19, 61, 46, 39, 47, 11, 39, 29, 37, 70, 52, 41, 37, 36, 51, 33, 29, 41, 46, 44, 24, 24, 58, 11, 53, 34, 44, 53, 39, 52, 74, 16, 53, 46, 38, 71, 57, 26, 38, 54, 54, 40, 47, 81, 31, 52, 29, 29, 52, 64, 30, 63, 40, 26, 42, 56, 55, 36, 37, 19, 40, 51, 29, 51, 57, 45, 31, 57, 32, 27, 39, 42, 31, 23, 42, 27, 48, 31, 35, 25, 52, 58, 62, 6, 80, 29, 72, 54, 43, 48, 29, 50, 49, 19, 53, 48, 36, 35, 35, 9, 55, 37, 20, 56, 46, 50, 13, 48, 13, 18, 41, 52, 35, 33, 43, 39, 25, 31, 41, 32, 55, 28, 41, 43, 15, 66, 16, 47, 18, 40, 25, 27, 45, 39, 30, 43, 52, 44, 24, 74, 45, 36, 28, 46, 43, 7, 27, 48, 44, 80, 39, 46, 39, 31, 34, 29, 19, 8, 36, 37, 12, 43, 54, 20, 22, 31, 28, 45, 19, 40, 47, 44, 54, 32, 20, 39, 51, 61, 42, 33, 72, 38, 30, 48, 28, 36, 32, 31, 59, 38, 37, 67, 68, 14, 20, 33, 59, 44, 35, 18, 49, 53, 63, 27, 45, 41, 38, 35, 42, 13, 34, 23, 26, 64, 21, 24, 55, 42, 52, 35, 26, 24, 33, 29, 51, 50, 21, 42, 58, 48, 25, 34, 46, 21, 44, 29, 42, 43, 55, 48, 38, 54, 27, 38, 29, 29, 40, 51, 20, 66, 29, 39, 41, 23, 54, 27, 37, 44, 29, 40, 52, 18, 35, 25, 31, 41, 22, 28, 22, 55, 55, 27, 17, 69, 75, 33, 32, 65, 34, 60, 40, 39, 36, 21, 36, 59, 10, 44, 16, 41, 25, 11, 30, 33, 40, 63, 27, 38, 56, 49, 49, 33, 30, 26, 61, 28, 26, 48, 37, 42, 46, 25, 50, 21, 33, 78, 26, 19, 36, 34, 40, 33, 42, 50, 35, 33, 52, 46, 46, 28, 23, 55, 26, 30, 31, 42, 40, 63, 63, 43, 32, 42, 32, 13, 37, 53, 42, 22, 51, 61, 18, 25, 20, 36, 20, 36, 19, 41, 30, 64, 57, 38, 35, 31, 40, 46, 45, 31, 42, 24, 37, 33, 28, 53, 9, 35, 20, 30, 9, 49, 30, 52, 51, 61, 41, 11, 29, 37, 50, 49, 32, 50, 72, 49, 58, 32, 45, 30, 19, 30, 52, 16, 41, 38, 41, 41, 33, 22, 31, 44, 57, 24, 67, 52, 29, 29, 10, 56, 60, 76, 33, 69, 26, 32, 62, 18, 20, 38, 16, 50, 30, 31, 36, 40, 46, 26, 75, 34, 46, 34, 61, 28, 65, 37, 30, 62, 65, 35, 50, 27, 51, 43, 34, 32, 22, 41, 30, 35, 30, 60, 44, 50, 46, 26, 27, 39, 62, 23, 25, 36, 41, 50, 35, 36, 21, 28, 18, 58, 22, 11, 27, 26, 41, 36, 30, 60, 37, 64, 29, 56, 21, 44, 33, 49, 49, 53, 38, 41, 24, 60, 38, 26, 60, 9, 54, 42, 23, 46, 77, 23, 42, 37, 30, 23, 15, 26, 35, 21, 25, 39, 45, 28, 58, 52, 26, 34, 55, 59, 11, 21, 7, 57, 17, 28, 41, 54, 29, 38, 39, 29, 19, 39, 45, 52, 54, 40, 38, 22, 42, 46, 35, 29, 20, 35, 21, 42, 40, 32, 50, 27, 48, 68, 25, 44, 42, 64, 35, 77, 15, 32, 32, 31, 45, 52, 14, 63, 48, 17, 45, 37, 16, 21, 13, 39, 26, 29, 49, 24, 41, 39, 43, 41, 35, 34, 21, 39, 37, 23, 28, 51, 51, 27, 33, 36, 40, 49, 39, 40, 50, 41, 62, 49, 59, 39, 48, 49, 16, 39, 51, 47, 32, 51, 27, 36, 39, 28, 50, 27, 28, 18, 36, 37, 28, 23, 27, 15, 60, 49, 29, 13, 24, 32, 36, 51, 23, 27, 70, 13, 28, 57, 19, 61, 27, 60, 23, 46, 39, 43, 22, 69, 42, 30, 39, 9, 17, 53, 27, 45, 52, 29, 7, 13, 45, 45, 47, 36, 65, 49, 59, 41, 33, 26, 65, 21, 23, 19, 48, 27, 56, 38, 57, 47, 42, 63, 45, 33, 15, 22, 14, 15, 30, 51, 38, 39, 41, 48, 31, 39, 61, 29, 75, 47, 35, 58, 50, 26, 40, 53, 65, 53, 43, 44, 56, 45, 60, 40, 22, 33, 59, 53, 47, 56, 67, 47, 46, 45, 34, 75, 48, 29, 62, 24, 34, 36, 55, 31, 67, 17, 36, 29, 51, 41, 33, 25, 48, 38, 16, 63, 46, 43, 46, 45, 35, 45, 77, 35, 28, 66, 51, 20, 41, 36, 23, 65, 40, 37, 30, 51, 23, 38, 15, 63, 47, 37, 24, 18, 28, 42, 27, 44, 36, 46, 43, 41, 46, 57, 49, 43, 40, 44, 53, 23, 33, 63, 30, 32, 36, 47, 43, 35, 7, 67, 48, 33, 54, 12, 64, 57, 12, 52, 8, 58, 45, 42, 43, 54, 54, 59, 32, 35, 36, 20, 43, 40, 37, 45, 38, 41, 50, 29, 15, 34, 73, 30, 37, 55, 47, 21, 33, 37, 39, 60, 14, 52, 67, 48, 12, 37, 40, 57, 59, 64, 47, 13, 31, 57, 59, 30, 30, 22, 39, 38, 13, 32, 46, 24, 47, 16, 44, 32, 49, 28, 61, 65, 24, 24, 19, 22, 42, 20, 51, 43, 25, 27, 54, 28, 55, 36, 27, 32, 27, 55, 51, 41, 46, 37, 53, 19, 68, 44, 65, 29, 22, 55, 14, 59, 76, 50, 37, 46, 49, 38, 20, 34, 58, 52, 62, 30, 48, 45, 37, 17, 51, 33, 41, 18, 34, 17, 22, 51, 48, 14, 69, 26, 47, 54, 31, 19, 49, 49, 53, 51, 50, 69, 53, 27, 24, 33, 48, 50, 37, 42, 48, 37, 49, 68, 34, 49, 22, 44, 26, 39, 32, 43, 32, 55, 46, 73, 42, 18, 57, 53, 27, 3, 46, 51, 49, 59, 57, 26, 34, 32, 22, 47, 60, 35, 42, 28, 71, 30, 35, 52, 54, 54, 35, 35, 34, 37, 42, 70, 42, 33, 35, 56, 24, 34, 52, 54, 53, 41, 45, 24, 16, 35, 65, 38, 35, 45, 18, 46, 16, 19, 25, 34, 30, 49, 54, 28, 32, 46, 42, 30, 32, 31, 38, 28, 43, 34, 51, 52, 58, 45, 31, 59, 24, 31, 52, 33, 53, 26, 48, 45, 61, 38, 57, 36, 28, 37, 41, 40, 47, 25, 54, 17, 50, 30, 56, 26, 42, 34, 23, 19, 70, 45, 47, 68, 39, 24, 35, 56, 39, 26, 25, 22, 49, 40, 38, 32, 31, 32, 56, 48, 45, 43, 40, 58, 44, 37, 54, 40, 19, 27, 12, 41, 34, 29, 17, 86, 50, 49, 38, 22, 72, 33, 19, 47, 47, 59, 64, 62, 65, 62, 29, 49, 43, 46, 30, 70, 59, 40, 34, 52, 47, 29, 42, 31, 28, 68, 52, 24, 32, 40, 18, 35, 28, 41, 31, 58, 29, 58, 36, 31, 32, 34, 48, 66, 32, 34, 48, 35, 31, 22, 38, 23, 21, 42, 41, 34, 24, 65, 55, 29, 47, 43, 56, 38, 18, 31, 32, 54, 18, 22, 43, 67, 55, 24, 39, 49, 35, 46, 28, 28, 49, 18, 52, 28, 74, 62, 60, 59, 23, 36, 28, 61, 58, 68, 16, 25, 41, 38, 21, 51, 28, 56, 43, 38, 24, 29, 65, 37, 44, 25, 41, 40, 36, 36, 38, 57, 63, 29, 41, 51, 16, 71, 59, 14, 19, 36, 20, 31, 59, 75, 24, 36, 52, 53, 29, 50, 51, 68, 24, 49, 49, 18, 63, 57, 46, 46, 34, 63, 38, 40, 39, 46, 45, 49, 3, 73, 23, 30, 43, 63, 45, 46, 33, 20, 65, 35, 65, 65, 44, 19, 38, 14, 41, 53, 54, 61, 55, 40, 28, 53, 38, 38, 49, 65, 61, 50, 31, 42, 48, 13, 26, 64, 71, 46, 29, 25, 28, 60, 62, 48, 37, 73, 43, 21, 32, 57, 48, 20, 43, 52, 45, 47, 67, 21, 29, 32, 16, 56, 32, 71, 35, 29, 38, 52, 37, 57, 52, 19, 39, 65, 26, 33, 36, 25, 47, 40, 44, 36, 55, 28, 25, 25, 27, 44, 42, 36, 64, 24, 30, 41, 24, 30, 54, 38, 35, 43, 27, 57, 51, 34, 20, 15, 45, 34, 34, 49, 14, 28, 61, 50, 53, 69, 33, 9, 29, 55, 54, 45, 27, 51, 29, 68, 52, 52, 59, 18, 28, 21, 35, 52, 13, 19, 34, 40, 41, 33, 43, 38, 54, 66, 77, 11, 31, 51, 59, 34, 25, 66, 44, 25, 41, 21, 52, 36, 40, 26, 32, 31, 42, 52, 41, 27, 41, 25, 27, 45, 38, 48, 45, 27, 44, 31, 19, 38, 21, 57, 38, 65, 36, 57, 37, 38, 73, 48, 51, 52, 54, 37, 55, 52, 20, 37, 38, 48, 16, 45, 20, 36, 43, 51, 12, 27, 60, 46, 63, 48, 67, 31, 42, 37, 64, 21, 30, 49, 47, 41, 29, 45, 52, 35, 32, 61, 13, 36, 44, 35, 34, 40, 26, 38, 46, 48, 60, 52, 19, 29, 35, 37, 22, 61, 23, 43, 28, 27, 63, 30, 34, 52, 35, 56, 50, 37, 31, 16, 51, 39, 53, 52, 16, 24, 57, 23, 29, 26, 39, 40, 51, 53, 38, 54, 47, 35, 44, 44, 51, 29, 43, 55, 61, 39, 33, 43, 42, 51, 11, 47, 29, 67, 25, 47, 10, 66, 61, 29, 61, 20, 18, 51, 50, 36, 22, 42, 44, 43, 55, 21, 23, 28, 68, 24, 31, 70, 73, 70, 43, 16, 49, 32, 19, 56, 73, 28, 32, 39, 15, 46, 18, 42, 20, 43, 15, 65, 66, 21, 59, 27, 44, 31, 31, 38, 72, 44, 32, 46, 41, 40, 58, 33, 53, 63, 22, 16, 38, 40, 24, 61, 19, 29, 11, 18, 23, 49, 22, 20, 60, 35, 53, 28, 59, 49, 56, 27, 35, 61, 47, 61, 50, 44, 40, 22, 29, 59, 61, 59, 21, 52, 32, 44, 36, 23, 55, 42, 12, 55, 33, 46, 49, 10, 56, 25, 29, 42, 53, 55, 50, 27, 18, 22, 50, 47, 41, 54, 20, 56, 62, 18, 40, 26, 6, 62, 41, 51, 33, 36, 53, 52, 60, 17, 48, 36, 30, 27, 41, 27, 57, 14, 41, 53, 36, 44, 52, 27, 20, 44, 71, 38, 18, 35, 39, 34, 42, 17, 58, 47, 22, 28, 48, 19, 37, 38, 39, 12, 29, 61, 19, 30, 18, 31, 41, 53, 35, 32, 52, 20, 55, 35, 41, 45, 45, 35, 35, 50, 37, 29, 28, 53, 26, 55, 51, 31, 44, 25, 29, 21, 45, 42, 35, 17, 51, 34, 47, 70, 51, 48, 11, 44, 15, 64, 40, 51, 25, 47, 48, 53, 49, 47, 47, 42, 52, 50, 42, 52, 39, 48, 35, 51, 53, 34, 49, 59, 47, 45, 58, 27, 26, 22, 37, 42, 66, 46, 29, 52, 54, 34, 52, 39, 33, 52, 43, 41, 35, 46, 37, 47, 28, 40, 11, 37, 51, 55, 28, 71, 54, 48, 18, 45, 52, 41, 25, 19, 24, 54, 45, 36, 31, 31, 10, 45, 36, 41, 44, 41, 30, 65, 57, 65, 68, 24, 34, 50, 40, 56, 36, 26, 33, 71, 45, 5, 21, 50, 52, 31, 22, 30, 35, 56, 18, 28, 15, 37, 28, 37, 60, 36, 25, 26, 55, 54, 44, 55, 49, 49, 16, 42, 19, 39, 42, 46, 46, 41, 30, 28, 42, 69, 52, 32, 61, 45, 38, 9, 24, 28, 13, 26, 54, 49, 37, 47, 38, 49, 22, 55, 53, 48, 19, 46, 33, 27, 61, 31, 47, 46, 25, 25, 54, 18, 52, 38, 36, 27, 11, 42, 44, 48, 71, 42, 22, 53, 67, 26, 32, 49, 40, 32, 16, 36, 52, 27, 39, 44, 62, 85, 51, 41, 55, 64, 50, 39, 27, 38, 40, 35, 61, 24, 14, 55, 48, 49, 50, 44, 14, 17, 42, 59, 30, 38, 23, 55, 29, 34, 34, 44, 55, 28, 9, 27, 49, 49, 12, 51, 38, 44, 46, 55, 26, 42, 38, 18, 53, 70, 28, 70, 58, 41, 42, 44, 31, 46, 43, 22, 59, 22, 17, 18, 24, 32, 31, 51, 26, 14, 65, 47, 47, 55, 55, 29, 27, 55, 36, 38, 52, 36, 31, 44, 29, 29, 36, 39, 34, 22, 32, 44, 45, 22, 37, 16, 65, 46, 41, 18, 52, 48, 36, 36, 8, 60, 64, 29, 61, 35, 41, 46, 29, 34, 71, 26, 49, 42, 46, 60, 56, 35, 11, 58, 27, 42, 55, 47, 39, 28, 36, 34, 59, 38, 50, 58, 34, 59, 31, 41, 39, 14, 42, 27, 33, 34, 45, 56, 63, 46, 40, 21, 45, 34, 33, 44, 49, 35, 25, 35, 19, 62, 42, 34, 49, 63, 43, 48, 59, 55, 37, 26, 16, 82, 61, 41, 19, 11, 32, 50, 47, 55, 27, 26, 21, 28, 40, 69, 42, 45, 74, 40, 19, 38, 21, 62, 39, 31, 59, 29, 59, 27, 27, 56, 37, 35, 28, 26, 59, 39, 74, 59, 31, 56, 67, 48, 31, 28, 72, 27, 29, 36, 26, 44, 32, 39, 39, 74, 61, 34, 47, 47, 55, 21, 32, 18, 55, 24, 33, 46, 37, 56, 29, 39, 55, 41, 34, 36, 31, 48, 31, 49, 31, 63, 10, 87, 42, 38, 28, 32, 46, 29, 34, 52, 59, 21, 17, 31, 30, 57, 37, 37, 26, 46, 29, 58, 63, 18, 66, 37, 55, 53, 43, 53, 21, 47, 31, 41, 38, 26, 49, 36, 53, 37, 45, 63, 48, 13, 48, 39, 26, 35, 45, 43, 27, 49, 39, 29, 16, 49, 26, 26, 44, 45, 21, 39, 41, 52, 15, 25, 53, 36, 58, 45, 50, 32, 47, 40, 47, 38, 54, 55, 58, 48, 43, 50, 60, 43, 48, 20, 13, 32, 44, 57, 39, 12, 44, 59, 58, 33, 43, 59, 65, 58, 41, 25, 51, 33, 54, 32, 32, 34, 41, 65, 41, 48, 34, 38, 14, 54, 40, 46, 73, 18, 33, 37, 30, 42, 39, 29, 71, 29, 21, 38, 17, 45, 49, 25, 52, 35, 34, 42, 14, 40, 19, 40, 35, 45, 28, 36, 32, 64, 43, 50, 33, 27, 60, 42, 36, 36, 49, 69, 61, 41, 60, 27, 55, 25, 42, 43, 22, 39, 57, 48, 35, 53, 52, 47, 41, 27, 58, 43, 59, 27, 48, 20, 31, 52, 26, 50, 23, 75, 49, 37, 45, 57, 56, 44, 39, 34, 45, 30, 18, 35, 30, 76, 28, 51, 40, 55, 61, 67, 53, 24, 42, 42, 36, 51, 53, 71, 39, 31, 30, 42, 35, 24, 41, 65, 51, 16, 43, 47, 41, 50, 41, 24, 60, 24, 32, 48, 24, 64, 31, 60, 43, 18, 44, 41, 17, 38, 12, 34, 42, 38, 48, 7, 13, 62, 63, 13, 41, 51, 31, 34, 29, 35, 48, 38, 15, 53, 32, 70, 40, 8, 31, 22, 27, 26, 54, 16, 43, 15, 22, 42, 48, 53, 64, 63, 20, 37, 40, 36, 4, 42, 42, 43, 32, 54, 66, 72, 30, 38, 30, 35, 41, 47, 21, 18, 63, 33, 31, 39, 59, 42, 20, 47, 27, 47, 59, 22, 34, 45, 14, 63, 40, 54, 25, 19, 44, 46, 60, 55, 47, 48, 16, 34, 37, 49, 22, 34, 17, 17, 59, 25, 44, 39, 47, 31, 40, 38, 50, 50, 50, 46, 45, 38, 39, 23, 12, 21, 47, 15, 37, 38, 20, 27, 58, 37, 70, 28, 18, 41, 12, 29, 30, 47, 27, 50, 29, 39, 17, 31, 17, 41, 29, 50, 42, 65, 32, 13, 17, 34, 54, 32, 48, 39, 67, 56, 15, 41, 36, 39, 28, 30, 45, 45, 34, 46, 30, 40, 56, 48, 26, 43, 22, 61, 31, 28, 29, 50, 16, 65, 54, 44, 52, 28, 32, 19, 42, 42, 39, 39, 59, 28, 60, 66, 23, 31, 24, 28, 13, 60, 38, 27, 35, 48, 59, 40, 62, 46, 70, 25, 54, 50, 32, 46, 57, 40, 38, 11, 45, 53, 21, 50, 30, 40, 43, 16, 32, 51, 42, 49, 60, 60, 37, 44, 73, 45, 55, 33, 42, 31, 49, 44, 21, 62, 50, 58, 26, 17, 71, 17, 27, 39, 50, 40, 43, 44, 31, 21, 44, 43, 22, 60, 29, 57, 20, 39, 44, 33, 34, 34, 41, 16, 25, 51, 23, 48, 17, 34, 24, 40, 27, 39, 28, 24, 26, 36, 37, 23, 57, 29, 56, 23, 41, 67, 35, 23, 10, 69, 56, 53, 50, 45, 32, 52, 39, 42, 30, 36, 47, 47, 36, 21, 21, 51, 24, 72, 10, 17, 52, 39, 39, 19, 20, 36, 54, 36, 34, 49, 63, 37, 24, 21, 43, 28, 65, 32, 29, 38, 23, 31, 9, 44, 51, 26, 52, 54, 28, 52, 46, 32, 50, 43, 46, 40, 24, 42, 38, 24, 46, 44, 40, 29, 35, 27, 55, 32, 28, 23, 13, 33, 31, 37, 18, 19, 37, 42, 18, 24, 36, 25, 54, 65, 6, 43, 27, 37, 68, 42, 33, 41, 48, 45, 66, 15, 27, 34]}, 'test_4': {'capacity': 100, 'num_items': 5000, 'items': [38, 34, 46, 40, 59, 55, 27, 37, 11, 63, 9, 31, 18, 52, 43, 50, 47, 34, 44, 47, 50, 41, 17, 40, 52, 55, 27, 29, 28, 54, 13, 57, 40, 15, 35, 27, 13, 28, 20, 8, 24, 47, 38, 48, 26, 34, 36, 47, 39, 10, 19, 57, 39, 44, 43, 56, 31, 48, 50, 26, 52, 52, 56, 41, 49, 37, 46, 37, 29, 47, 43, 30, 32, 24, 47, 37, 55, 47, 43, 10, 50, 27, 50, 27, 33, 51, 15, 43, 45, 48, 44, 59, 32, 44, 40, 46, 66, 39, 51, 30, 38, 25, 38, 28, 48, 50, 14, 41, 39, 31, 33, 38, 17, 24, 32, 23, 18, 55, 41, 40, 66, 35, 51, 63, 50, 88, 31, 63, 34, 51, 58, 32, 43, 59, 65, 43, 40, 31, 47, 66, 47, 45, 61, 24, 43, 53, 37, 36, 57, 19, 51, 6, 29, 41, 30, 11, 25, 50, 53, 53, 52, 42, 22, 29, 39, 25, 25, 34, 52, 50, 42, 59, 42, 50, 52, 49, 22, 60, 37, 50, 45, 24, 30, 40, 64, 33, 64, 47, 26, 55, 29, 39, 60, 27, 34, 41, 43, 35, 49, 40, 39, 51, 33, 45, 48, 64, 19, 47, 23, 41, 53, 35, 43, 33, 39, 34, 63, 27, 42, 34, 54, 52, 74, 27, 59, 71, 56, 33, 41, 16, 74, 34, 38, 41, 29, 30, 28, 28, 51, 29, 53, 27, 6, 15, 35, 63, 16, 52, 43, 21, 41, 21, 36, 32, 52, 39, 32, 25, 37, 52, 58, 21, 32, 35, 61, 52, 23, 58, 36, 19, 51, 61, 42, 40, 30, 34, 25, 28, 28, 19, 20, 30, 34, 63, 30, 53, 49, 24, 20, 54, 45, 18, 52, 49, 43, 37, 33, 44, 42, 43, 50, 33, 25, 29, 64, 43, 63, 45, 58, 59, 50, 73, 48, 34, 8, 26, 50, 21, 80, 24, 36, 26, 37, 65, 53, 50, 50, 60, 33, 81, 43, 57, 25, 67, 35, 35, 47, 52, 14, 60, 36, 27, 52, 24, 37, 44, 57, 42, 33, 37, 39, 43, 58, 44, 35, 46, 50, 47, 74, 25, 46, 27, 53, 54, 37, 46, 39, 27, 32, 49, 77, 37, 68, 34, 63, 56, 44, 45, 26, 74, 47, 52, 37, 37, 67, 26, 28, 39, 49, 25, 34, 40, 30, 56, 47, 50, 56, 32, 26, 50, 51, 40, 27, 61, 54, 42, 25, 43, 17, 41, 49, 26, 51, 22, 15, 52, 50, 31, 28, 31, 55, 32, 20, 33, 54, 49, 32, 42, 68, 47, 64, 6, 37, 38, 44, 37, 25, 9, 60, 44, 38, 40, 62, 48, 49, 55, 40, 55, 41, 40, 42, 51, 46, 61, 54, 45, 34, 48, 80, 63, 28, 31, 41, 49, 30, 41, 13, 48, 65, 59, 33, 42, 24, 48, 48, 30, 75, 43, 62, 60, 65, 15, 19, 33, 47, 36, 21, 31, 41, 23, 38, 51, 42, 58, 14, 42, 12, 20, 37, 35, 42, 43, 15, 43, 28, 42, 34, 55, 35, 43, 49, 28, 16, 40, 26, 27, 41, 35, 27, 46, 38, 31, 36, 21, 35, 64, 35, 33, 42, 13, 49, 51, 59, 53, 18, 27, 67, 20, 38, 26, 37, 33, 44, 31, 21, 23, 46, 38, 36, 65, 39, 52, 35, 42, 30, 38, 33, 45, 72, 21, 35, 54, 29, 57, 52, 33, 20, 30, 45, 33, 53, 73, 48, 49, 32, 36, 62, 66, 30, 56, 53, 29, 42, 24, 46, 39, 20, 43, 38, 52, 25, 58, 22, 38, 44, 48, 34, 40, 32, 8, 35, 45, 25, 68, 30, 45, 67, 56, 40, 22, 30, 74, 27, 48, 33, 67, 39, 11, 37, 53, 45, 57, 42, 45, 50, 47, 40, 40, 61, 64, 51, 28, 18, 12, 49, 43, 47, 44, 55, 31, 53, 37, 31, 47, 48, 31, 39, 42, 50, 14, 33, 42, 39, 50, 37, 55, 47, 50, 78, 37, 38, 30, 61, 39, 48, 30, 26, 48, 62, 46, 27, 54, 38, 36, 46, 34, 35, 64, 24, 39, 75, 29, 70, 38, 28, 39, 10, 24, 49, 47, 33, 47, 58, 30, 10, 26, 28, 43, 33, 29, 46, 36, 35, 19, 36, 10, 37, 31, 7, 42, 46, 63, 82, 49, 42, 42, 22, 54, 42, 50, 30, 51, 61, 48, 43, 29, 13, 33, 36, 58, 38, 47, 59, 57, 19, 33, 56, 7, 49, 41, 49, 11, 40, 68, 28, 11, 36, 39, 26, 26, 64, 25, 36, 18, 53, 33, 39, 45, 62, 30, 23, 38, 31, 26, 35, 26, 4, 44, 39, 34, 29, 23, 36, 62, 39, 41, 38, 14, 55, 19, 46, 57, 51, 37, 19, 27, 33, 36, 34, 38, 43, 27, 66, 30, 27, 46, 48, 48, 59, 81, 58, 40, 50, 35, 45, 51, 53, 53, 46, 52, 39, 17, 49, 35, 32, 41, 54, 46, 33, 42, 44, 24, 43, 45, 28, 29, 44, 44, 34, 46, 44, 17, 54, 27, 39, 42, 41, 26, 39, 57, 38, 17, 21, 52, 47, 24, 32, 37, 45, 13, 62, 48, 31, 42, 19, 23, 30, 50, 15, 31, 28, 42, 51, 45, 47, 23, 40, 52, 85, 54, 36, 20, 38, 34, 18, 25, 14, 34, 43, 21, 35, 39, 45, 33, 52, 24, 40, 51, 29, 26, 51, 41, 64, 57, 29, 45, 48, 35, 37, 38, 42, 46, 36, 43, 26, 41, 62, 62, 63, 6, 21, 30, 30, 21, 36, 33, 58, 41, 53, 29, 42, 9, 57, 27, 37, 48, 25, 23, 31, 33, 32, 42, 35, 15, 13, 61, 30, 16, 47, 25, 31, 62, 5, 50, 19, 38, 61, 27, 26, 35, 40, 24, 31, 30, 18, 18, 41, 36, 61, 11, 46, 7, 8, 42, 39, 28, 28, 33, 37, 37, 44, 6, 53, 35, 29, 35, 67, 29, 31, 49, 34, 46, 21, 23, 35, 48, 28, 38, 67, 45, 59, 44, 50, 61, 24, 49, 58, 9, 16, 40, 14, 18, 34, 47, 37, 56, 22, 41, 39, 35, 59, 57, 34, 24, 16, 48, 36, 38, 44, 23, 79, 24, 10, 36, 51, 32, 39, 43, 55, 28, 27, 25, 42, 45, 63, 24, 41, 47, 19, 32, 26, 57, 30, 24, 32, 62, 73, 35, 65, 30, 67, 38, 41, 30, 37, 48, 22, 58, 50, 8, 42, 44, 72, 42, 67, 24, 64, 55, 54, 42, 13, 13, 27, 27, 19, 53, 28, 33, 23, 36, 70, 54, 55, 37, 56, 35, 35, 53, 3, 43, 26, 43, 29, 69, 45, 61, 45, 46, 19, 40, 25, 43, 38, 62, 45, 58, 71, 45, 28, 42, 42, 11, 56, 58, 39, 35, 66, 23, 30, 42, 35, 50, 24, 44, 61, 56, 42, 41, 56, 48, 54, 21, 35, 51, 21, 29, 16, 44, 40, 50, 34, 38, 63, 58, 20, 51, 30, 39, 33, 29, 7, 39, 36, 59, 16, 45, 54, 49, 73, 30, 55, 32, 53, 83, 28, 44, 38, 54, 32, 23, 30, 50, 12, 52, 52, 46, 28, 47, 32, 26, 8, 60, 9, 36, 27, 27, 69, 49, 45, 31, 16, 48, 14, 31, 36, 44, 35, 48, 47, 51, 55, 40, 43, 42, 21, 51, 70, 53, 18, 37, 37, 53, 26, 28, 53, 65, 33, 27, 17, 42, 32, 19, 65, 31, 13, 32, 42, 24, 45, 54, 51, 48, 45, 54, 60, 31, 62, 43, 43, 43, 58, 33, 9, 46, 43, 16, 77, 52, 55, 46, 70, 78, 35, 42, 27, 24, 62, 40, 41, 43, 60, 43, 46, 27, 54, 47, 49, 51, 35, 42, 46, 21, 37, 47, 13, 39, 42, 21, 24, 45, 11, 50, 29, 36, 43, 49, 46, 28, 36, 47, 49, 42, 35, 57, 44, 41, 51, 59, 68, 37, 40, 32, 67, 21, 35, 28, 36, 35, 60, 39, 35, 39, 13, 51, 24, 8, 21, 59, 34, 42, 33, 41, 44, 22, 35, 33, 45, 80, 36, 42, 26, 25, 45, 46, 23, 30, 27, 53, 58, 50, 71, 39, 35, 49, 18, 56, 43, 16, 51, 24, 60, 53, 57, 51, 27, 34, 49, 47, 55, 37, 13, 11, 34, 53, 21, 24, 29, 61, 56, 45, 15, 33, 40, 31, 18, 36, 44, 9, 20, 41, 48, 34, 38, 35, 65, 48, 18, 11, 37, 28, 39, 51, 59, 42, 54, 44, 41, 10, 30, 54, 44, 38, 22, 44, 11, 54, 30, 40, 50, 49, 34, 26, 33, 39, 31, 44, 51, 47, 40, 41, 9, 42, 28, 45, 28, 36, 47, 50, 7, 47, 64, 43, 44, 46, 46, 11, 45, 26, 29, 31, 61, 44, 53, 71, 31, 69, 6, 42, 38, 51, 34, 51, 38, 45, 27, 29, 32, 25, 32, 25, 36, 43, 56, 49, 36, 36, 60, 46, 24, 36, 45, 57, 56, 41, 43, 35, 18, 52, 33, 41, 66, 71, 25, 28, 17, 11, 40, 34, 34, 12, 38, 31, 24, 52, 39, 19, 66, 55, 24, 43, 24, 33, 39, 66, 30, 24, 8, 62, 55, 64, 40, 59, 53, 42, 52, 29, 26, 24, 40, 32, 43, 30, 38, 55, 39, 16, 27, 33, 58, 31, 66, 35, 30, 26, 18, 34, 50, 35, 23, 30, 36, 36, 21, 33, 46, 52, 48, 31, 30, 29, 9, 27, 26, 40, 39, 45, 38, 60, 40, 34, 49, 45, 78, 34, 29, 56, 38, 20, 83, 19, 34, 37, 33, 54, 69, 47, 32, 49, 45, 48, 42, 19, 44, 30, 21, 39, 30, 29, 67, 37, 29, 33, 74, 38, 36, 10, 26, 27, 26, 49, 57, 56, 26, 34, 33, 9, 20, 22, 36, 53, 16, 69, 28, 35, 58, 53, 9, 50, 43, 30, 58, 49, 39, 40, 27, 42, 40, 42, 19, 39, 46, 58, 62, 30, 48, 30, 39, 36, 17, 37, 51, 18, 56, 48, 18, 24, 39, 21, 48, 8, 45, 36, 42, 44, 38, 50, 40, 51, 27, 23, 47, 16, 62, 49, 37, 44, 50, 17, 45, 45, 68, 12, 22, 59, 54, 38, 11, 43, 51, 21, 34, 29, 49, 41, 17, 33, 78, 18, 30, 47, 71, 33, 56, 44, 55, 46, 48, 50, 45, 31, 45, 27, 50, 46, 36, 43, 40, 59, 52, 53, 44, 29, 33, 59, 29, 55, 48, 38, 38, 21, 52, 22, 35, 38, 19, 31, 51, 47, 52, 41, 29, 26, 28, 60, 27, 40, 61, 44, 39, 36, 34, 37, 37, 39, 48, 73, 26, 24, 34, 29, 32, 59, 40, 41, 31, 14, 63, 19, 38, 45, 40, 58, 27, 55, 66, 45, 31, 28, 51, 22, 31, 15, 16, 31, 29, 34, 55, 52, 33, 46, 43, 70, 44, 40, 33, 31, 28, 52, 22, 37, 61, 17, 15, 21, 42, 54, 35, 25, 63, 15, 38, 52, 49, 58, 39, 65, 32, 31, 52, 43, 46, 44, 51, 34, 43, 56, 60, 80, 10, 46, 18, 17, 25, 37, 33, 34, 61, 31, 44, 64, 22, 30, 22, 35, 57, 38, 37, 42, 56, 39, 54, 25, 57, 52, 58, 36, 27, 36, 43, 24, 50, 60, 36, 16, 26, 18, 62, 50, 19, 39, 15, 34, 27, 49, 33, 22, 49, 45, 33, 43, 39, 65, 20, 44, 58, 42, 24, 38, 36, 23, 37, 41, 35, 33, 10, 31, 58, 59, 24, 36, 39, 61, 27, 43, 34, 37, 37, 31, 55, 44, 28, 11, 48, 34, 56, 41, 67, 51, 35, 26, 40, 22, 31, 46, 36, 21, 29, 22, 37, 31, 30, 68, 37, 47, 37, 33, 31, 72, 48, 33, 40, 44, 47, 52, 20, 25, 61, 27, 33, 57, 61, 46, 17, 29, 15, 68, 31, 35, 24, 54, 42, 24, 9, 12, 48, 52, 43, 43, 42, 23, 57, 53, 75, 36, 59, 46, 40, 38, 37, 51, 52, 30, 62, 41, 41, 71, 57, 20, 40, 51, 26, 60, 46, 57, 12, 9, 47, 26, 30, 30, 51, 27, 20, 47, 64, 36, 32, 34, 68, 31, 34, 18, 42, 24, 25, 17, 20, 78, 61, 47, 61, 19, 42, 27, 28, 52, 35, 14, 37, 51, 44, 44, 57, 48, 49, 46, 23, 41, 39, 37, 45, 70, 38, 30, 16, 36, 45, 26, 53, 29, 39, 29, 59, 28, 42, 31, 60, 52, 18, 34, 38, 52, 32, 40, 60, 81, 58, 55, 19, 28, 62, 54, 52, 35, 13, 9, 26, 26, 70, 49, 25, 30, 33, 12, 54, 29, 32, 51, 30, 64, 54, 28, 39, 23, 31, 22, 38, 40, 54, 42, 75, 34, 15, 33, 63, 37, 32, 21, 34, 47, 47, 39, 39, 49, 33, 31, 49, 43, 45, 55, 62, 39, 17, 53, 47, 39, 42, 22, 47, 64, 29, 17, 34, 24, 34, 47, 4, 32, 54, 63, 52, 32, 31, 43, 38, 36, 34, 21, 46, 60, 35, 25, 40, 18, 36, 50, 34, 27, 73, 48, 31, 48, 37, 19, 24, 61, 20, 36, 60, 32, 25, 39, 40, 38, 52, 21, 7, 52, 79, 60, 58, 57, 50, 50, 27, 40, 45, 21, 36, 28, 23, 38, 41, 35, 42, 6, 26, 23, 36, 19, 59, 41, 28, 45, 45, 57, 33, 55, 63, 42, 19, 35, 47, 17, 44, 31, 11, 7, 15, 36, 66, 42, 19, 41, 40, 30, 49, 49, 55, 51, 48, 21, 51, 39, 32, 42, 38, 61, 44, 26, 12, 25, 28, 52, 14, 56, 23, 47, 36, 51, 25, 31, 43, 34, 58, 25, 30, 34, 24, 90, 49, 36, 20, 55, 49, 43, 22, 64, 76, 33, 57, 50, 28, 42, 40, 23, 56, 39, 27, 23, 40, 47, 38, 49, 52, 39, 39, 43, 17, 44, 28, 43, 49, 53, 70, 31, 48, 63, 29, 25, 31, 45, 29, 40, 43, 46, 17, 27, 60, 56, 53, 54, 66, 30, 44, 29, 46, 32, 22, 40, 28, 34, 37, 19, 51, 42, 26, 19, 28, 66, 36, 33, 62, 23, 70, 62, 54, 49, 44, 39, 59, 58, 60, 39, 75, 41, 59, 33, 63, 51, 53, 38, 28, 52, 80, 39, 50, 29, 63, 48, 54, 32, 19, 11, 55, 27, 39, 36, 33, 18, 39, 15, 38, 23, 35, 46, 34, 31, 25, 26, 55, 30, 32, 22, 56, 45, 39, 31, 21, 28, 68, 36, 35, 45, 17, 36, 47, 23, 37, 17, 42, 53, 37, 42, 53, 45, 23, 34, 30, 26, 42, 39, 31, 43, 62, 55, 40, 75, 37, 41, 40, 26, 35, 26, 65, 18, 41, 37, 31, 43, 60, 62, 44, 42, 74, 41, 51, 30, 40, 49, 52, 55, 36, 22, 41, 50, 19, 53, 11, 32, 24, 18, 34, 62, 47, 39, 35, 34, 32, 35, 23, 36, 28, 37, 48, 65, 46, 57, 7, 26, 69, 38, 58, 50, 47, 38, 21, 50, 35, 45, 40, 46, 36, 48, 58, 36, 30, 54, 38, 56, 24, 44, 35, 30, 33, 27, 81, 44, 80, 45, 49, 38, 19, 23, 30, 27, 40, 71, 35, 67, 18, 33, 73, 46, 33, 44, 51, 31, 52, 44, 57, 51, 26, 27, 67, 23, 14, 36, 34, 41, 40, 55, 23, 37, 18, 21, 26, 43, 33, 42, 53, 21, 35, 52, 51, 30, 48, 30, 37, 50, 46, 8, 43, 30, 54, 53, 35, 58, 38, 47, 35, 8, 52, 38, 37, 81, 29, 43, 55, 37, 25, 49, 41, 39, 32, 38, 46, 59, 18, 46, 46, 44, 14, 35, 50, 49, 16, 33, 44, 36, 42, 77, 33, 36, 51, 39, 18, 58, 10, 43, 58, 60, 55, 41, 25, 63, 20, 39, 69, 29, 30, 65, 59, 23, 50, 25, 33, 36, 31, 44, 23, 54, 8, 49, 14, 31, 39, 61, 58, 32, 59, 37, 32, 57, 26, 38, 64, 61, 45, 37, 39, 45, 36, 28, 41, 38, 28, 20, 37, 57, 30, 36, 53, 42, 58, 26, 45, 18, 74, 53, 48, 52, 23, 49, 20, 35, 8, 27, 38, 65, 28, 7, 48, 29, 48, 50, 37, 41, 56, 36, 43, 44, 30, 32, 21, 48, 40, 29, 52, 56, 37, 57, 34, 16, 54, 20, 56, 33, 16, 38, 25, 74, 20, 52, 25, 60, 50, 29, 44, 60, 35, 32, 41, 42, 26, 43, 25, 30, 36, 31, 23, 48, 14, 29, 32, 59, 41, 32, 27, 23, 34, 41, 30, 46, 66, 52, 66, 31, 39, 25, 78, 24, 47, 33, 54, 7, 34, 56, 28, 33, 31, 40, 31, 15, 62, 42, 47, 44, 43, 25, 35, 32, 45, 6, 45, 20, 65, 13, 29, 47, 49, 43, 37, 51, 38, 50, 52, 48, 40, 55, 49, 23, 42, 38, 18, 21, 45, 56, 37, 33, 28, 50, 46, 43, 34, 67, 27, 22, 33, 44, 37, 27, 50, 46, 37, 14, 49, 24, 53, 34, 26, 54, 27, 35, 46, 45, 78, 18, 41, 25, 29, 30, 17, 17, 7, 50, 21, 69, 49, 61, 15, 35, 33, 7, 27, 20, 32, 45, 40, 54, 18, 15, 54, 42, 50, 41, 69, 45, 48, 49, 59, 27, 26, 63, 66, 35, 32, 50, 18, 31, 51, 62, 57, 59, 19, 47, 51, 32, 44, 65, 26, 43, 60, 65, 33, 50, 22, 32, 34, 45, 59, 90, 68, 52, 38, 37, 25, 46, 49, 29, 15, 46, 26, 36, 37, 50, 35, 29, 23, 31, 19, 68, 37, 34, 33, 49, 65, 43, 41, 52, 35, 37, 30, 30, 37, 30, 41, 58, 22, 36, 66, 43, 50, 49, 29, 39, 42, 70, 20, 30, 62, 41, 29, 29, 45, 38, 59, 46, 5, 31, 52, 44, 51, 60, 45, 33, 50, 40, 39, 46, 45, 63, 32, 53, 53, 43, 31, 34, 69, 36, 61, 18, 28, 26, 38, 31, 19, 55, 42, 53, 39, 62, 29, 55, 59, 22, 53, 29, 46, 39, 26, 26, 61, 38, 26, 50, 59, 53, 52, 42, 24, 25, 54, 15, 48, 43, 37, 31, 51, 26, 59, 37, 66, 68, 39, 39, 47, 28, 45, 42, 57, 41, 66, 21, 25, 58, 29, 40, 28, 27, 78, 39, 44, 27, 67, 63, 35, 63, 22, 49, 26, 44, 36, 34, 34, 38, 42, 44, 43, 41, 52, 7, 20, 51, 38, 50, 58, 35, 36, 27, 35, 48, 34, 67, 20, 48, 31, 40, 14, 65, 45, 75, 35, 32, 24, 46, 44, 30, 20, 50, 17, 38, 58, 60, 24, 53, 51, 56, 44, 65, 18, 52, 32, 35, 56, 37, 42, 48, 54, 48, 18, 22, 42, 32, 40, 39, 40, 41, 57, 53, 36, 26, 34, 26, 61, 42, 54, 50, 46, 56, 34, 43, 33, 41, 35, 20, 16, 32, 54, 50, 54, 60, 70, 24, 35, 47, 30, 13, 31, 46, 41, 36, 44, 48, 32, 33, 33, 56, 51, 39, 30, 46, 41, 54, 39, 48, 46, 43, 26, 34, 27, 43, 25, 57, 61, 62, 19, 47, 23, 27, 36, 48, 47, 58, 60, 23, 36, 31, 32, 10, 44, 46, 33, 49, 31, 67, 24, 40, 52, 15, 40, 44, 28, 48, 37, 40, 39, 45, 34, 50, 47, 29, 44, 20, 54, 35, 30, 51, 35, 44, 34, 54, 48, 35, 51, 28, 52, 36, 18, 40, 55, 19, 62, 58, 31, 22, 19, 32, 59, 42, 30, 32, 51, 67, 20, 38, 33, 94, 37, 59, 69, 61, 33, 35, 40, 43, 33, 28, 38, 48, 52, 43, 21, 55, 64, 38, 57, 47, 34, 39, 35, 40, 67, 34, 35, 64, 25, 21, 31, 41, 44, 24, 49, 54, 32, 23, 64, 64, 32, 37, 55, 45, 38, 45, 34, 35, 36, 35, 41, 29, 34, 55, 34, 45, 18, 48, 38, 24, 35, 45, 49, 34, 57, 34, 51, 57, 21, 47, 53, 64, 40, 54, 58, 14, 51, 63, 29, 56, 41, 64, 25, 21, 40, 75, 13, 50, 34, 45, 50, 65, 32, 42, 19, 41, 33, 18, 26, 35, 50, 40, 22, 34, 44, 55, 56, 10, 31, 13, 39, 20, 47, 12, 44, 52, 41, 43, 52, 31, 49, 35, 37, 58, 20, 17, 14, 38, 59, 27, 56, 21, 36, 54, 35, 26, 17, 26, 50, 32, 58, 37, 60, 57, 52, 42, 15, 54, 21, 18, 40, 48, 29, 38, 42, 48, 21, 46, 41, 48, 19, 20, 36, 21, 36, 49, 53, 16, 53, 22, 25, 62, 45, 23, 28, 30, 63, 44, 23, 37, 28, 22, 65, 43, 60, 21, 8, 25, 28, 52, 58, 46, 59, 4, 47, 64, 23, 35, 31, 33, 50, 45, 45, 24, 46, 51, 52, 68, 47, 19, 48, 63, 30, 38, 25, 41, 40, 59, 40, 23, 41, 27, 71, 30, 31, 73, 72, 52, 49, 30, 58, 53, 32, 72, 44, 45, 52, 43, 66, 43, 48, 17, 41, 27, 72, 24, 20, 63, 42, 36, 13, 41, 67, 40, 41, 34, 30, 39, 23, 38, 26, 46, 19, 26, 65, 46, 20, 31, 32, 49, 60, 58, 41, 9, 18, 29, 54, 34, 47, 51, 28, 44, 52, 44, 22, 56, 30, 52, 14, 41, 71, 50, 27, 15, 44, 25, 43, 39, 38, 58, 39, 51, 49, 27, 50, 52, 31, 17, 44, 45, 15, 42, 34, 51, 53, 55, 18, 66, 61, 22, 22, 36, 27, 64, 13, 76, 65, 36, 22, 30, 42, 57, 34, 52, 17, 58, 71, 39, 75, 24, 44, 18, 37, 64, 45, 23, 16, 22, 49, 46, 33, 46, 39, 41, 35, 30, 37, 25, 24, 47, 65, 20, 43, 55, 71, 27, 21, 55, 55, 48, 46, 8, 46, 46, 34, 19, 54, 58, 52, 42, 28, 13, 66, 33, 43, 21, 51, 55, 41, 43, 44, 48, 17, 22, 41, 39, 44, 53, 20, 32, 39, 64, 27, 50, 44, 43, 51, 34, 24, 26, 61, 42, 17, 45, 37, 60, 30, 22, 23, 44, 43, 33, 55, 29, 32, 31, 31, 51, 65, 80, 43, 57, 44, 29, 24, 12, 64, 42, 52, 24, 51, 22, 39, 42, 55, 33, 48, 47, 62, 31, 46, 14, 25, 55, 34, 21, 29, 47, 44, 21, 44, 58, 59, 24, 29, 38, 51, 39, 25, 44, 37, 62, 13, 48, 48, 39, 43, 12, 6, 52, 27, 47, 44, 34, 54, 42, 49, 38, 34, 35, 62, 35, 36, 49, 32, 19, 48, 61, 32, 57, 58, 27, 52, 44, 39, 26, 23, 42, 45, 56, 55, 52, 35, 38, 31, 31, 28, 20, 40, 48, 44, 40, 71, 63, 48, 44, 52, 47, 35, 63, 62, 25, 37, 35, 35, 39, 32, 43, 45, 58, 68, 25, 37, 50, 48, 30, 51, 31, 28, 52, 63, 50, 81, 36, 59, 48, 44, 27, 18, 19, 26, 54, 54, 39, 43, 24, 40, 13, 39, 22, 23, 29, 53, 34, 23, 61, 56, 43, 49, 48, 49, 42, 9, 27, 33, 39, 29, 26, 53, 46, 46, 43, 41, 28, 34, 29, 33, 43, 44, 15, 41, 30, 32, 55, 75, 50, 26, 55, 68, 15, 17, 22, 55, 33, 52, 23, 39, 39, 39, 74, 18, 21, 37, 36, 23, 64, 51, 20, 65, 38, 25, 68, 58, 33, 53, 27, 25, 59, 35, 49, 51, 28, 38, 40, 36, 27, 46, 24, 17, 47, 38, 64, 52, 18, 32, 20, 27, 48, 37, 46, 77, 10, 39, 33, 48, 29, 38, 37, 41, 81, 39, 19, 54, 46, 33, 60, 29, 52, 40, 14, 54, 38, 27, 34, 41, 37, 34, 57, 18, 23, 36, 31, 73, 39, 40, 33, 31, 22, 35, 36, 50, 28, 41, 31, 18, 38, 53, 27, 43, 33, 29, 34, 36, 48, 18, 39, 38, 27, 47, 51, 68, 44, 39, 16, 29, 54, 16, 42, 38, 43, 33, 25, 27, 56, 57, 57, 50, 59, 42, 46, 58, 48, 52, 37, 10, 25, 63, 18, 49, 26, 32, 23, 31, 47, 28, 11, 32, 54, 17, 66, 27, 31, 30, 50, 49, 36, 20, 32, 72, 30, 27, 14, 58, 40, 41, 51, 39, 48, 19, 49, 58, 58, 50, 54, 40, 29, 30, 33, 33, 44, 39, 39, 32, 37, 45, 38, 48, 28, 41, 40, 53, 52, 29, 38, 44, 57, 22, 39, 24, 45, 20, 38, 53, 43, 38, 54, 40, 35, 17, 53, 18, 34, 44, 18, 38, 55, 48, 46, 35, 26, 21, 34, 62, 53, 46, 30, 6, 18, 63, 56, 15, 58, 68, 47, 49, 47, 43, 26, 42, 31, 28, 42, 18, 35, 66, 45, 53, 67, 41, 31, 34, 48, 42, 57, 40, 47, 16, 67, 45, 61, 8, 12, 44, 74, 35, 41, 40, 37, 38, 46, 37, 56, 32, 57, 25, 51, 48, 47, 31, 60, 15, 64, 39, 46, 37, 38, 10, 48, 31, 62, 13, 26, 34, 33, 53, 61, 28, 67, 8, 33, 24, 32, 26, 66, 35, 52, 32, 43, 43, 27, 45, 34, 33, 35, 51, 33, 48, 39, 33, 40, 20, 30, 32, 34, 71, 62, 29, 54, 31, 24, 47, 11, 22, 18, 34, 41, 36, 65, 41, 35, 63, 27, 29, 44, 38, 13, 36, 23, 25, 40, 55, 47, 49, 46, 36, 53, 38, 16, 13, 28, 63, 28, 49, 15, 46, 12, 24, 50, 24, 49, 61, 79, 37, 21, 45, 33, 38, 38, 30, 49, 48, 52, 49, 45, 48, 9, 47, 49, 44, 49, 28, 28, 43, 10, 46, 52, 15, 51, 45, 54, 30, 10, 50, 25, 44, 25, 53, 50, 13, 65, 20, 66, 25, 39, 10, 40, 10, 38, 50, 36, 30, 51, 46, 53, 31, 41, 42, 35, 62, 51, 14, 33, 37, 57, 43, 56, 21, 22, 50, 41, 50, 27, 32, 11, 49, 56, 23, 54, 32, 46, 44, 29, 31, 25, 19, 50, 37, 46, 47, 48, 51, 20, 43, 57, 33, 44, 46, 70, 34, 45, 13, 36, 53, 28, 50, 10, 48, 27, 19, 52, 22, 51, 49, 65, 21, 40, 40, 18, 53, 27, 38, 37, 32, 74, 52, 23, 40, 54, 55, 51, 61, 34, 37, 43, 33, 33, 73, 48, 46, 48, 54, 49, 20, 33, 37, 43, 15, 36, 42, 40, 29, 43, 18, 31, 56, 36, 24, 57, 48, 67, 20, 16, 15, 62, 35, 53, 36, 43, 35, 35, 51, 62, 53, 66, 44, 34, 50, 34, 40, 58, 44, 52, 25, 30, 23, 52, 32, 50, 27, 28, 48, 30, 53, 50, 50, 35, 15, 22, 19, 45, 51, 22, 39, 36, 49, 61, 57, 58, 40, 43, 81, 79, 54, 41, 20, 22, 37, 12, 34, 61, 23, 37, 57, 36, 38, 43, 30, 60, 20, 45, 35, 32, 23, 27, 33, 30, 22, 24, 51, 23, 26, 35, 10, 70, 48, 38, 11, 24, 67, 32, 24, 62, 49, 24, 30, 49, 51, 31, 32, 14, 59, 50, 51, 30, 68, 38, 19, 37, 34, 46, 37, 63, 32, 21, 41, 43, 24, 41, 67, 26, 36, 46, 54, 61, 49, 35, 16, 16, 16, 56, 41, 41, 17, 40, 12, 46, 48, 19, 73, 31, 11, 52, 50, 26, 41, 55, 35, 23, 56, 22, 33, 60, 44, 23, 40, 23, 31, 43, 46, 26, 40, 40, 56, 29, 33, 24, 20, 53, 62, 22, 51, 68, 62, 56, 30, 56, 49, 64, 35, 39, 29, 36, 47, 24, 74, 36, 39, 54, 18, 21, 55, 34, 70, 24, 37, 31, 39, 63, 11, 42, 61, 31, 62, 46, 25, 38, 19, 53, 33, 26, 23, 52, 52, 36, 30, 10, 48, 58, 26, 29, 16, 23, 34, 22, 15, 26, 42, 15, 18, 46, 59, 58, 30, 42, 49, 16, 14, 50, 29, 27, 41, 48, 59, 42, 32, 33, 43, 43, 53, 52, 43, 63, 44, 19, 46, 43, 34, 50, 50, 23, 37, 36, 76, 50, 49, 54, 40, 35, 52, 42, 15, 32, 27, 22, 36, 26, 62, 31, 37, 50, 59, 35, 28, 18, 33, 39, 56, 44, 53, 39, 13, 12, 42, 44, 56, 58, 45, 31, 44, 74, 28, 46, 44, 31, 36, 40, 35, 41, 23, 34, 27, 27, 64, 39, 31, 51, 15, 38, 58, 41, 30, 31, 56, 44, 43, 41, 31, 10, 56, 66, 19, 54, 43, 35, 50, 40, 43, 50, 39, 19, 29, 17, 16, 46, 33, 11, 38, 47, 47, 33, 21, 45, 35, 37, 78, 69, 42, 59, 50, 30, 43, 50, 49, 29, 61, 46, 62, 25, 39, 67, 32, 43, 21, 26, 16, 26, 18, 55, 37, 33, 23, 33, 45, 47, 32, 51, 45, 23, 56, 49, 75, 28, 21, 34, 28, 40, 47, 34, 37, 43, 25, 31, 56, 65, 38, 14, 25, 33, 20, 7, 40, 39, 25, 56, 28, 51, 24, 52, 35, 46, 57, 52, 38, 56, 31, 18, 14, 20, 45, 36, 28, 24, 30, 50, 39, 43, 64, 31, 22, 48, 42, 42, 68, 51, 16, 37, 22, 43, 55, 22, 26, 41, 40, 29, 27, 35, 29, 59, 42, 50, 59, 31, 29, 52, 55, 30, 26, 30, 30, 39, 32, 40, 19, 45, 30, 32, 12, 52, 37, 26, 45, 36, 60, 58, 15, 9, 38, 38, 36, 44, 47, 27, 38, 46, 36, 44, 26, 28, 24, 32, 44, 14, 31, 62, 60, 61, 12, 45, 38, 55, 27, 30, 30, 70, 48, 38, 49, 33, 46, 47, 39, 43, 22, 29, 31, 37, 69, 14, 45, 81, 38, 45, 32, 13, 41, 7, 38, 44, 54, 45, 35, 13, 35, 53, 55, 25, 9, 15, 36, 40, 26, 35, 25, 45, 15, 55, 47, 22, 50, 29, 41, 35, 46, 25, 33, 23, 20, 35, 34, 31, 32, 29, 42, 46, 19, 60, 57, 31, 29, 31, 36, 50, 59, 51, 33, 31, 61, 64, 28, 58, 48, 43, 24, 33, 40, 43, 21, 48, 37, 44, 14, 31, 28, 41, 33, 50, 52, 59, 54, 50, 23, 47, 27, 28, 54, 44, 34, 28, 60, 46, 37, 29, 28, 54, 14, 26, 19, 41, 46, 31, 20, 74, 27, 31, 38, 48, 24, 48, 57, 72, 11, 43]}}\n\n\n \n #self.datasets = read_dataset_from_file('../weibull_instances/test_dataset_10k.pkl')\n # for test_num in range(5):\n # test_key = f'test_{test_num}'\n # data = np.array(self.datasets['Weibull 5k'][test_key]['items'])\n # print(data)\n # print(self.datasets['Weibull 5k'][test_key]['capacity'])\n # data = data / self.datasets['Weibull 5k'][test_key]['capacity']\n # self.datasets['Weibull 5k'][test_key]['capacity'] = 1.0\n # top_500_items = data[:1000]\n # self.datasets['Weibull 5k'][test_key]['items'] = top_500_items\n # self.datasets['Weibull 5k'][test_key]['num_items'] = 1000\n\n\n def read_dataset_from_file(self,filename):\n with open(filename, 'rb') as file:\n dataset = pickle.load(file)\n\n transformed_dataset = {}\n\n for num_items, instances in dataset.items():\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"] = {}\n for instance_num, items in enumerate(instances, 1):\n instance_name = f\"test_{instance_num-1}\"\n instance_data = {\n \"capacity\": 100,\n \"num_items\": num_items,\n \"items\": items\n }\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"][instance_name] = instance_data\n\n return transformed_dataset\n \n def l1_bound(self,items: tuple, capacity: int) -> float:\n \"\"\"Computes L1 lower bound on OPT for bin packing.\n\n Args:\n items: Tuple of items to pack into bins.\n capacity: Capacity of bins.\n\n Returns:\n Lower bound on number of bins required to pack items.\n \"\"\"\n return np.ceil(np.sum(items) / capacity)\n\n\n def l1_bound_dataset(self,instances: dict) -> float:\n \"\"\"Computes the mean L1 lower bound across a dataset of bin packing instances.\n\n Args:\n instances: Dictionary containing a set of bin packing instances.\n\n Returns:\n Average L1 lower bound on number of bins required to pack items.\n \"\"\"\n l1_bounds = []\n for name in instances:\n instance = instances[name]\n l1_bounds.append(self.l1_bound(instance['items'], instance['capacity']))\n return np.mean(l1_bounds)\n\n def get_instances(self,capacity,size):\n opt_num_bins = {}\n self.datasets = self.read_dataset_from_file('./testingdata/test_dataset_'+size+'.pkl')\n for test_num in range(len(self.datasets)):\n test_key = f'test_{test_num}'\n self.datasets['Weibull '+size][test_key]['capacity'] = capacity\n\n for name, dataset in self.datasets.items():\n opt_num_bins[name] = self.l1_bound_dataset(dataset)\n print(opt_num_bins)\n return self.datasets, opt_num_bins\n\n\n" }, { "path": "examples/bp_online/evaluation/heuristic.py", "content": "# example heuristic\n# replace it with your own heuristic designed by EoH\n\ndef score(item, bins):\n scores = item - bins\n return scores" }, { "path": "examples/bp_online/evaluation/results.txt", "content": "Weibull 1k, 100, Excess: 4.87%\nWeibull 5k, 100, Excess: 4.08%\nWeibull 10k, 100, Excess: 4.09%\nWeibull 1k, 300, Excess: 4.48%\nWeibull 5k, 300, Excess: 3.83%\nWeibull 10k, 300, Excess: 3.87%\nWeibull 1k, 500, Excess: 4.50%\nWeibull 5k, 500, Excess: 3.91%\nWeibull 10k, 500, Excess: 3.95%\n" }, { "path": "examples/bp_online/evaluation/runEval.py", "content": "# -------\n# Evaluaiton code for EoH on Online Bin Packing\n#--------\n# More results may refer to \n# Fei Liu, Xialiang Tong, Mingxuan Yuan, Xi Lin, Fu Luo, Zhenkun Wang, Zhichao Lu, Qingfu Zhang \n# \"Evolution of Heuristics: Towards Efficient Automatic Algorithm Design Using Large Language Model\" \n# ICML 2024, https://arxiv.org/abs/2401.02051.\n\nimport importlib\nfrom get_instance import GetData\nfrom evaluation import Evaluation\n\neva = Evaluation()\n\ncapacity_list = [100,300,500]\n#size_list = ['1k','5k','10k','100k']\nsize_list = ['1k','5k','10k']\nwith open(\"results.txt\", \"w\") as file:\n for capacity in capacity_list:\n for size in size_list:\n getdate = GetData()\n instances, lb = getdate.get_instances(capacity, size) \n heuristic_module = importlib.import_module(\"heuristic\")\n heuristic = importlib.reload(heuristic_module) \n \n for name, dataset in instances.items():\n \n avg_num_bins = -eva.evaluateGreedy(dataset,heuristic)\n excess = (avg_num_bins - lb[name]) / lb[name]\n \n result = f'{name}, {capacity}, Excess: {100 * excess:.2f}%'\n print(result)\n file.write(result + \"\\n\")\n \n" }, { "path": "examples/bp_online/evaluation/testingdata/generate_instances.py", "content": "import numpy as np\nimport pickle\n\ndef generate_weibull_dataset(num_instances, num_items, clipping_limit):\n dataset = {}\n\n for i in range(num_instances):\n items = []\n\n # Generate random samples from Weibull(45, 3) distribution\n samples = np.random.weibull(3, num_items) * 45\n\n # Clip the samples at the specified limit\n samples = np.clip(samples, 1, clipping_limit)\n\n # Round the item sizes to the nearest integer\n sizes = np.round(samples).astype(int)\n\n # Add the items to the instance\n for size in sizes:\n items.append(size)\n\n if num_items not in dataset:\n dataset[num_items] = []\n\n dataset[num_items].append(items)\n\n return dataset\n \ndef read_dataset_from_file(filename):\n with open(filename, 'rb') as file:\n dataset = pickle.load(file)\n\n transformed_dataset = {}\n\n for num_items, instances in dataset.items():\n transformed_dataset[f\"Weibull {num_items}k\"] = {}\n for instance_num, items in enumerate(instances, 1):\n instance_name = f\"test_{instance_num}\"\n instance_data = {\n \"capacity\": 100,\n \"num_items\": num_items,\n \"items\": items\n }\n transformed_dataset[f\"Weibull {num_items}k\"][instance_name] = instance_data\n\n return transformed_dataset\n\n# Generate training dataset with 5 instances and 5,000 items\ntraining_dataset = generate_weibull_dataset(5, 5000, 100)\n\n# Generate validation dataset with 5 instances and 5,000 items\nvalidation_dataset = generate_weibull_dataset(5, 5000, 100)\n\n# Generate test dataset with 5 instances and 5,000 items\ntest_dataset_05k = generate_weibull_dataset(5, 1000, 100)\n\n\n# Generate test dataset with 5 instances and 5,000 items\ntest_dataset_1k = generate_weibull_dataset(5, 2000, 100)\n\n# Generate test dataset with 5 instances and 5,000 items\ntest_dataset_5k = generate_weibull_dataset(5, 5000, 100)\n\n# Generate test dataset with 5 instances and 10,000 items\ntest_dataset_10k = generate_weibull_dataset(5, 10000, 100)\n\n# Generate test dataset with 1 instance and 100,000 items\ntest_dataset_100k = generate_weibull_dataset(1, 100000, 100)\n\n# Write datasets to pickle files\ndef write_dataset_to_file(dataset, filename):\n with open(filename, 'wb') as file:\n pickle.dump(dataset, file)\n\nwrite_dataset_to_file(training_dataset, 'training_dataset_5k.pkl')\n#write_dataset_to_file(validation_dataset, 'validation_dataset.pkl')\n#write_dataset_to_file(test_dataset_05k, 'test_dataset_1k.pkl')\n#write_dataset_to_file(test_dataset_1k, 'test_dataset_2k.pkl')\n#write_dataset_to_file(test_dataset_5k, 'test_dataset_5k.pkl')\n#write_dataset_to_file(test_dataset_10k, 'test_dataset_10k.pkl')\n#write_dataset_to_file(test_dataset_100k, 'test_dataset_100k.pkl')\n\n\n#test_dataset_5k = read_dataset_from_file('test_dataset_5k.pkl')\n#test_dataset_10k = read_dataset_from_file('test_dataset_10k.pkl')\n#test_dataset_100k = read_dataset_from_file('test_dataset_100k.pkl')\nprint(test_dataset_5k)\n\n\n" }, { "path": "examples/bp_online/results/pops/population_generation_0.json", "content": "[\n {\n \"algorithm\": \"\\nMy new algorithm assigns an item to the bin with the highest score at each step, considering the rest capacity of the bins, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n scores = np.zeros(len(bins))\\n \\n for i in range(len(bins)):\\n if bins[i] == np.max(bins):\\n scores[i] = 0\\n else:\\n scores[i] = (np.max(bins) - bins[i]) / item\\n \\n return scores\",\n \"objective\": 0.03984,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nNew algorithm: The novel score function assigns a score to each bin based on the bin's rest capacity and the item size, prioritizing bins with larger rest capacities while considering the maximum capacity constraint, in order to minimize the number of used bins.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n max_capacity = np.max(bins)\\n scores = np.zeros_like(bins)\\n \\n for i in range(len(bins)):\\n if bins[i] == max_capacity:\\n scores[i] = -1\\n else:\\n scores[i] = bins[i] - item - (max_capacity - bins[i])\\n \\n return scores\",\n \"objective\": 0.83389,\n \"other_inf\": null\n },\n {\n \"algorithm\": \"\\nThe algorithm first calculates the normalized rest capacities of the bins based on the item size, then assigns a score to each bin by considering both the normalized capacity and the order of processing, finally returning the list of scores for the bins for assignment.\\n\",\n \"code\": \"import numpy as np\\n\\ndef score(item, bins):\\n normalized_caps = bins / item\\n sorted_caps_idx = np.argsort(normalized_caps)[::-1]\\n scores = np.zeros_like(bins)\\n for i, idx in enumerate(sorted_caps_idx):\\n scores[idx] = normalized_caps[idx] - (i * 0.01) # Adjusting score based on order of processing\\n return scores\",\n \"objective\": 1.50196,\n \"other_inf\": null\n }\n]" }, { "path": "examples/bp_online/runEoH.py", "content": "from eoh import eoh\nfrom eoh.utils.getParas import Paras\n\n# Parameter initilization #\nparas = Paras() \n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = \"bp_online\", #['tsp_construct','bp_online']\n llm_api_endpoint = \"xxx\", # set your LLM endpoint\n llm_api_key = \"xxx\", # set your key\n llm_model = \"gpt-3.5-turbo\",\n ec_pop_size = 4, # number of samples in each population\n ec_n_pop = 4, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False)\n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()" }, { "path": "examples/bp_online_localLLM/evaluation/evaluation.py", "content": "import numpy as np\n\n\nclass Evaluation():\n def __init__(self):\n \n self.instances, self.lb = None, None\n\n\n def get_valid_bin_indices(self,item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns indices of bins in which item can fit.\"\"\"\n return np.nonzero((bins - item) >= 0)[0]\n\n\n def online_binpack(self,items: tuple, bins: np.ndarray, alg):\n \"\"\"Performs online binpacking of `items` into `bins`.\"\"\"\n # Track which items are added to each bin.\n packing = [[] for _ in bins]\n # Add items to bins.\n for item in items:\n # Extract bins that have sufficient space to fit item.\n valid_bin_indices = self.get_valid_bin_indices(item, bins)\n # Score each bin based on heuristic.\n priorities = alg.score(item, bins[valid_bin_indices])\n # Add item to bin with highest priority.\n #print(priorities)\n best_bin = valid_bin_indices[np.argmax(priorities)]\n bins[best_bin] -= item\n packing[best_bin].append(item)\n # Remove unused bins from packing.\n packing = [bin_items for bin_items in packing if bin_items]\n return packing, bins\n\n\n # @funsearch.run\n def evaluateGreedy(self,instances: dict,alg) -> float:\n\n \"\"\"Evaluate heuristic function on a set of online binpacking instances.\"\"\"\n # List storing number of bins used for each instance.\n num_bins = []\n # Perform online binpacking for each instance.\n #print(len(instances))\n for name in instances:\n #print(name)\n instance = instances[name]\n capacity = instance['capacity']\n items = np.array(instance['items'])\n\n # items = items/capacity\n # capacity = 1.0\n\n # Create num_items bins so there will always be space for all items,\n # regardless of packing order. Array has shape (num_items,).\n bins = np.array([capacity for _ in range(instance['num_items'])])\n # Pack items into bins and return remaining capacity in bins_packed, which\n # has shape (num_items,).\n _, bins_packed = self.online_binpack(items, bins, alg)\n # If remaining capacity in a bin is equal to initial capacity, then it is\n # unused. Count number of used bins.\n num_bins.append((bins_packed != capacity).sum())\n # Score of heuristic function is negative of average number of bins used\n # across instances (as we want to minimize number of bins).\n return -np.mean(num_bins)\n\n\n\n\n\n" }, { "path": "examples/bp_online_localLLM/evaluation/get_instance.py", "content": "import numpy as np\nimport pickle\nclass GetData():\n def __init__(self) -> None:\n self.datasets = {}\n # Data from the Weibull 5k test dataset, containing 5 bin packing instances\n # each with 5,000 items.\n self.datasets['Weibull 5k'] = {'test_0': {'capacity': 1000, 'num_items': 5000, 'items': [48, 66, 48, 32, 72, 37, 41, 21, 58, 35, 18, 53, 52, 42, 51, 30, 42, 44, 58, 62, 28, 20, 27, 53, 59, 56, 46, 60, 21, 49, 29, 58, 31, 47, 34, 41, 28, 49, 22, 37, 31, 27, 50, 46, 39, 52, 40, 41, 31, 57, 53, 57, 35, 39, 38, 40, 34, 22, 30, 48, 34, 34, 48, 53, 23, 57, 50, 67, 18, 40, 38, 38, 42, 53, 38, 37, 53, 62, 22, 51, 34, 51, 24, 92, 60, 29, 39, 49, 24, 33, 67, 65, 62, 57, 60, 29, 53, 29, 54, 52, 37, 59, 55, 69, 20, 41, 47, 44, 36, 48, 61, 33, 53, 36, 47, 38, 39, 35, 41, 31, 42, 41, 45, 49, 25, 20, 71, 61, 35, 33, 42, 11, 39, 68, 43, 30, 51, 31, 68, 29, 40, 45, 41, 23, 46, 65, 37, 60, 45, 38, 28, 45, 42, 30, 39, 59, 36, 60, 58, 32, 49, 19, 55, 46, 55, 53, 46, 32, 56, 29, 23, 22, 26, 19, 37, 24, 50, 44, 33, 27, 26, 34, 38, 21, 58, 48, 66, 37, 40, 10, 37, 27, 56, 30, 49, 19, 52, 17, 41, 29, 38, 53, 21, 36, 37, 23, 35, 26, 25, 33, 11, 34, 18, 69, 36, 50, 40, 19, 65, 51, 53, 35, 35, 45, 21, 27, 60, 35, 56, 14, 65, 40, 24, 39, 49, 85, 54, 32, 28, 27, 9, 28, 44, 47, 65, 59, 23, 46, 36, 46, 18, 20, 20, 36, 50, 71, 57, 63, 31, 35, 47, 35, 35, 41, 48, 19, 53, 69, 26, 43, 45, 27, 52, 19, 49, 45, 29, 32, 29, 22, 52, 15, 47, 39, 26, 41, 27, 31, 63, 50, 21, 30, 21, 42, 43, 21, 71, 21, 34, 29, 80, 41, 37, 51, 35, 33, 45, 26, 44, 30, 41, 22, 55, 26, 43, 35, 15, 31, 32, 53, 36, 33, 25, 19, 29, 64, 56, 17, 30, 13, 66, 19, 39, 51, 38, 39, 54, 37, 37, 17, 8, 45, 58, 19, 48, 51, 41, 53, 69, 33, 37, 29, 25, 41, 54, 51, 26, 29, 66, 60, 36, 33, 17, 31, 48, 73, 16, 26, 46, 25, 25, 33, 57, 49, 28, 62, 44, 22, 19, 65, 25, 60, 39, 39, 36, 45, 40, 45, 43, 28, 45, 28, 54, 44, 54, 32, 62, 67, 34, 31, 29, 47, 38, 35, 69, 57, 40, 20, 37, 27, 56, 25, 57, 54, 36, 45, 56, 49, 35, 77, 71, 53, 46, 41, 25, 50, 50, 44, 79, 52, 19, 44, 43, 36, 40, 36, 36, 35, 51, 35, 41, 67, 47, 46, 13, 53, 56, 37, 41, 46, 36, 70, 29, 18, 35, 59, 7, 51, 36, 52, 24, 40, 21, 74, 21, 23, 28, 47, 43, 40, 50, 61, 65, 17, 59, 60, 52, 53, 19, 51, 63, 59, 25, 42, 50, 50, 60, 61, 27, 37, 25, 55, 69, 45, 51, 36, 47, 20, 56, 39, 20, 43, 50, 34, 42, 37, 60, 48, 18, 41, 42, 35, 34, 46, 20, 61, 57, 25, 42, 72, 16, 39, 29, 64, 37, 44, 39, 32, 47, 61, 23, 41, 21, 38, 33, 67, 60, 54, 66, 51, 70, 39, 34, 47, 16, 38, 48, 54, 15, 34, 34, 14, 22, 25, 32, 11, 19, 44, 32, 36, 43, 20, 55, 46, 38, 62, 43, 35, 19, 47, 31, 17, 42, 31, 39, 49, 37, 53, 36, 64, 29, 19, 42, 47, 45, 9, 45, 52, 59, 35, 67, 25, 27, 55, 44, 47, 38, 17, 24, 61, 68, 35, 36, 18, 23, 50, 20, 36, 35, 48, 32, 29, 62, 23, 32, 36, 25, 15, 57, 50, 43, 43, 30, 24, 56, 52, 65, 17, 48, 29, 64, 52, 20, 45, 60, 54, 38, 57, 27, 32, 20, 44, 18, 18, 32, 38, 36, 39, 17, 41, 42, 67, 39, 21, 30, 61, 40, 43, 31, 16, 40, 41, 38, 38, 11, 43, 40, 17, 41, 65, 48, 42, 47, 24, 86, 26, 29, 48, 34, 19, 55, 65, 53, 68, 43, 41, 28, 50, 49, 15, 42, 26, 14, 45, 26, 61, 54, 25, 44, 28, 43, 43, 18, 44, 21, 52, 47, 38, 32, 55, 54, 24, 75, 38, 53, 24, 24, 39, 63, 32, 47, 32, 67, 32, 43, 25, 52, 47, 48, 50, 56, 18, 48, 64, 66, 37, 36, 42, 30, 37, 53, 32, 73, 40, 55, 30, 38, 34, 60, 39, 22, 43, 32, 13, 44, 41, 23, 48, 28, 42, 22, 34, 49, 55, 27, 34, 38, 43, 35, 71, 61, 44, 32, 22, 27, 82, 38, 50, 30, 54, 29, 48, 45, 45, 42, 64, 36, 44, 26, 52, 12, 32, 46, 50, 23, 56, 54, 23, 47, 46, 38, 60, 45, 38, 58, 48, 53, 37, 34, 45, 25, 38, 32, 11, 46, 38, 32, 42, 58, 59, 12, 50, 49, 44, 46, 37, 53, 58, 47, 34, 45, 39, 58, 31, 29, 36, 38, 36, 49, 56, 45, 34, 28, 7, 31, 42, 15, 49, 51, 47, 26, 20, 52, 26, 50, 32, 34, 33, 51, 73, 17, 45, 40, 35, 24, 30, 46, 42, 21, 11, 49, 32, 67, 50, 47, 54, 44, 57, 55, 36, 51, 37, 26, 35, 20, 42, 32, 46, 30, 33, 44, 67, 23, 47, 45, 39, 14, 37, 41, 29, 59, 53, 21, 15, 49, 37, 56, 19, 28, 48, 41, 30, 27, 32, 10, 83, 58, 22, 40, 46, 52, 34, 34, 43, 22, 17, 28, 67, 58, 35, 33, 18, 11, 44, 35, 20, 60, 50, 44, 23, 49, 29, 44, 66, 37, 44, 15, 62, 27, 41, 52, 32, 44, 28, 11, 32, 28, 72, 35, 21, 54, 42, 57, 37, 26, 37, 43, 49, 24, 57, 37, 37, 41, 19, 27, 40, 49, 50, 14, 59, 61, 34, 35, 53, 33, 36, 31, 42, 32, 60, 20, 46, 41, 31, 12, 59, 22, 60, 53, 22, 58, 19, 27, 23, 37, 32, 42, 58, 24, 38, 29, 26, 57, 17, 34, 34, 17, 35, 61, 48, 45, 31, 38, 22, 47, 38, 25, 47, 47, 43, 38, 46, 52, 45, 39, 64, 21, 35, 31, 32, 44, 46, 31, 75, 48, 23, 47, 31, 34, 22, 24, 50, 28, 32, 23, 49, 53, 51, 30, 70, 36, 28, 54, 14, 61, 61, 37, 24, 38, 34, 43, 26, 38, 44, 55, 42, 33, 35, 29, 28, 18, 19, 51, 39, 28, 54, 43, 43, 41, 27, 29, 17, 14, 44, 46, 77, 55, 34, 61, 45, 29, 24, 32, 38, 15, 72, 9, 19, 25, 59, 21, 53, 13, 42, 38, 29, 30, 39, 59, 41, 13, 38, 46, 21, 49, 41, 28, 19, 61, 24, 15, 52, 34, 23, 55, 31, 36, 54, 45, 66, 69, 37, 54, 69, 50, 62, 15, 49, 29, 56, 25, 64, 30, 34, 25, 23, 46, 52, 59, 40, 58, 59, 58, 57, 21, 25, 44, 28, 41, 44, 13, 17, 81, 29, 68, 61, 42, 38, 66, 10, 57, 49, 63, 31, 67, 63, 20, 65, 35, 14, 73, 55, 37, 69, 46, 48, 24, 39, 42, 45, 27, 48, 43, 24, 30, 41, 24, 43, 49, 45, 61, 56, 43, 39, 59, 61, 36, 22, 54, 38, 73, 44, 26, 49, 50, 44, 44, 30, 26, 16, 46, 29, 25, 54, 26, 52, 63, 61, 23, 23, 44, 31, 48, 27, 32, 28, 33, 46, 41, 35, 29, 56, 62, 81, 58, 67, 7, 46, 79, 36, 18, 37, 48, 34, 48, 56, 38, 18, 27, 33, 53, 21, 37, 43, 31, 50, 27, 39, 25, 41, 58, 24, 46, 43, 62, 28, 51, 20, 65, 57, 70, 15, 31, 73, 13, 32, 64, 32, 17, 60, 37, 35, 27, 49, 38, 42, 37, 49, 26, 51, 66, 19, 20, 63, 44, 21, 40, 44, 65, 44, 50, 51, 26, 45, 53, 46, 35, 65, 26, 62, 37, 24, 64, 13, 60, 54, 46, 37, 31, 48, 29, 18, 31, 12, 45, 31, 29, 31, 32, 35, 40, 40, 26, 41, 55, 21, 14, 47, 54, 41, 64, 13, 17, 68, 28, 11, 47, 65, 35, 25, 56, 68, 48, 25, 67, 43, 38, 10, 56, 31, 69, 42, 61, 45, 40, 54, 34, 32, 48, 65, 52, 58, 40, 28, 21, 20, 53, 41, 28, 45, 25, 69, 47, 38, 62, 30, 47, 16, 35, 61, 29, 29, 32, 76, 51, 50, 38, 58, 33, 48, 48, 48, 19, 22, 66, 42, 53, 35, 17, 30, 27, 45, 24, 52, 14, 32, 63, 44, 34, 31, 72, 28, 43, 17, 40, 58, 54, 25, 38, 41, 46, 22, 34, 26, 56, 31, 29, 19, 56, 46, 38, 57, 40, 30, 46, 36, 61, 34, 39, 52, 49, 8, 56, 49, 21, 30, 23, 34, 43, 50, 49, 70, 53, 19, 47, 48, 47, 22, 22, 49, 33, 53, 28, 39, 55, 32, 41, 31, 24, 30, 32, 42, 33, 31, 54, 38, 22, 63, 42, 29, 54, 50, 56, 39, 49, 38, 40, 33, 42, 61, 59, 22, 26, 41, 19, 71, 54, 46, 31, 47, 45, 21, 53, 40, 31, 67, 45, 66, 37, 21, 38, 45, 34, 41, 41, 45, 32, 46, 66, 60, 43, 41, 31, 56, 64, 39, 65, 19, 70, 38, 66, 28, 35, 26, 35, 20, 60, 31, 52, 30, 28, 26, 34, 50, 50, 57, 33, 48, 18, 28, 20, 68, 43, 41, 19, 36, 58, 56, 27, 48, 14, 45, 52, 31, 65, 40, 31, 19, 58, 43, 67, 16, 55, 60, 25, 43, 44, 29, 76, 50, 32, 55, 21, 37, 51, 64, 60, 41, 22, 31, 37, 30, 60, 33, 57, 40, 32, 10, 36, 33, 75, 47, 18, 64, 50, 32, 29, 41, 17, 38, 64, 58, 57, 44, 29, 50, 21, 66, 42, 40, 20, 39, 25, 44, 42, 18, 57, 46, 29, 42, 11, 17, 49, 38, 22, 3, 43, 34, 38, 21, 65, 44, 24, 28, 58, 51, 73, 34, 35, 36, 64, 59, 54, 16, 22, 39, 35, 18, 40, 50, 29, 43, 41, 11, 27, 49, 86, 49, 27, 44, 28, 19, 31, 31, 78, 23, 25, 44, 17, 34, 36, 22, 39, 6, 31, 41, 34, 37, 35, 36, 62, 65, 18, 25, 42, 39, 61, 41, 61, 55, 58, 32, 56, 44, 37, 35, 39, 41, 39, 58, 59, 45, 42, 50, 46, 76, 62, 27, 50, 50, 66, 30, 59, 34, 9, 32, 12, 30, 47, 32, 30, 48, 41, 33, 71, 39, 47, 49, 20, 28, 67, 29, 35, 28, 17, 45, 72, 48, 26, 52, 26, 71, 34, 60, 27, 64, 20, 54, 34, 57, 38, 68, 38, 45, 54, 21, 39, 41, 13, 39, 31, 22, 53, 44, 52, 18, 41, 22, 34, 30, 29, 12, 38, 62, 51, 61, 11, 35, 46, 33, 49, 9, 38, 50, 35, 38, 52, 42, 68, 48, 69, 50, 56, 40, 55, 34, 66, 25, 34, 25, 28, 53, 51, 40, 51, 77, 26, 29, 42, 36, 44, 43, 39, 62, 54, 42, 34, 7, 59, 65, 21, 39, 51, 57, 25, 28, 47, 37, 33, 66, 47, 31, 52, 46, 25, 51, 41, 41, 24, 47, 41, 47, 42, 65, 56, 40, 39, 68, 9, 50, 53, 27, 59, 49, 38, 38, 52, 29, 15, 46, 40, 47, 40, 45, 21, 36, 31, 27, 35, 48, 50, 54, 21, 32, 47, 29, 24, 35, 37, 38, 40, 51, 52, 56, 29, 17, 40, 51, 41, 28, 16, 55, 38, 25, 43, 43, 58, 55, 63, 46, 24, 26, 35, 48, 56, 20, 48, 54, 43, 24, 48, 29, 43, 24, 1, 44, 45, 27, 62, 41, 30, 32, 69, 39, 45, 45, 42, 22, 43, 25, 7, 32, 38, 49, 42, 50, 53, 61, 45, 53, 52, 50, 40, 56, 31, 47, 27, 46, 51, 18, 35, 23, 25, 35, 37, 49, 38, 44, 36, 35, 54, 28, 59, 48, 34, 42, 57, 39, 44, 49, 42, 47, 40, 37, 35, 59, 3, 55, 43, 32, 60, 17, 15, 39, 34, 28, 52, 21, 39, 32, 61, 50, 57, 46, 58, 52, 49, 43, 34, 30, 25, 69, 58, 28, 34, 40, 25, 40, 25, 42, 42, 35, 42, 30, 33, 19, 38, 49, 65, 45, 57, 6, 32, 45, 48, 73, 26, 47, 28, 66, 36, 38, 44, 53, 29, 48, 40, 59, 47, 53, 43, 39, 55, 59, 42, 33, 45, 47, 30, 30, 30, 40, 57, 63, 48, 50, 69, 56, 40, 37, 31, 55, 75, 47, 18, 34, 35, 46, 19, 20, 25, 47, 13, 32, 57, 40, 24, 38, 16, 46, 9, 24, 44, 51, 46, 25, 54, 17, 33, 41, 21, 50, 45, 48, 33, 32, 35, 33, 43, 18, 56, 61, 83, 48, 21, 36, 73, 34, 32, 38, 19, 55, 37, 62, 61, 47, 74, 47, 41, 31, 47, 52, 81, 54, 42, 47, 45, 61, 25, 36, 57, 27, 42, 61, 35, 52, 87, 61, 21, 20, 28, 50, 20, 23, 57, 67, 64, 17, 38, 42, 18, 47, 34, 64, 22, 41, 44, 38, 19, 12, 31, 36, 45, 49, 54, 40, 29, 26, 33, 39, 36, 43, 32, 34, 32, 13, 37, 45, 67, 36, 43, 53, 19, 53, 33, 29, 36, 47, 45, 47, 21, 34, 23, 43, 26, 16, 35, 48, 31, 47, 53, 34, 31, 65, 50, 47, 18, 8, 38, 48, 40, 27, 46, 55, 22, 23, 62, 29, 50, 20, 64, 51, 46, 49, 40, 27, 47, 31, 33, 28, 42, 52, 41, 33, 25, 33, 27, 23, 52, 43, 47, 7, 14, 41, 50, 33, 38, 20, 49, 39, 55, 47, 43, 22, 24, 63, 29, 65, 24, 27, 21, 57, 34, 42, 29, 28, 74, 31, 25, 45, 26, 10, 45, 5, 35, 15, 33, 18, 27, 58, 51, 48, 18, 56, 34, 44, 48, 36, 49, 87, 48, 57, 35, 23, 51, 24, 33, 34, 39, 42, 20, 37, 47, 52, 31, 27, 12, 41, 37, 80, 33, 61, 79, 71, 47, 70, 60, 60, 29, 42, 50, 27, 32, 57, 41, 27, 31, 62, 37, 30, 53, 46, 40, 33, 62, 39, 31, 74, 25, 55, 36, 71, 59, 28, 8, 28, 23, 53, 13, 31, 10, 56, 50, 43, 22, 53, 63, 33, 34, 50, 30, 34, 38, 36, 29, 31, 22, 42, 74, 37, 50, 39, 42, 29, 62, 38, 16, 58, 18, 49, 58, 50, 23, 36, 36, 53, 47, 57, 77, 45, 44, 11, 32, 22, 48, 49, 25, 61, 59, 69, 21, 44, 69, 45, 41, 22, 44, 40, 53, 43, 27, 46, 21, 47, 26, 24, 35, 38, 46, 59, 66, 48, 45, 42, 36, 47, 45, 18, 49, 5, 27, 33, 58, 78, 16, 23, 19, 34, 16, 46, 48, 36, 28, 56, 49, 53, 43, 27, 42, 41, 39, 23, 24, 20, 30, 12, 68, 30, 59, 29, 17, 29, 39, 51, 47, 59, 50, 52, 23, 18, 78, 67, 16, 50, 49, 19, 55, 31, 47, 50, 66, 45, 35, 33, 39, 42, 42, 49, 42, 62, 46, 56, 31, 43, 36, 38, 34, 61, 50, 55, 42, 34, 31, 38, 21, 52, 33, 65, 46, 26, 55, 35, 19, 60, 69, 47, 24, 22, 45, 40, 43, 66, 49, 32, 21, 15, 51, 50, 20, 69, 15, 36, 31, 49, 18, 41, 21, 48, 18, 47, 11, 46, 45, 19, 60, 53, 28, 15, 24, 47, 49, 40, 40, 65, 56, 54, 61, 61, 25, 39, 61, 30, 47, 49, 31, 27, 23, 51, 37, 47, 46, 36, 19, 45, 22, 46, 31, 48, 8, 44, 20, 15, 12, 52, 30, 24, 40, 19, 54, 70, 58, 55, 25, 48, 49, 49, 23, 60, 23, 44, 39, 28, 57, 55, 58, 44, 27, 36, 53, 32, 18, 36, 58, 41, 25, 43, 46, 18, 40, 35, 55, 46, 37, 23, 16, 56, 26, 32, 34, 61, 68, 48, 43, 35, 40, 51, 30, 22, 41, 25, 43, 63, 44, 50, 27, 38, 32, 30, 20, 46, 63, 6, 50, 32, 47, 59, 29, 48, 30, 72, 19, 41, 34, 21, 24, 29, 43, 46, 36, 68, 37, 41, 66, 52, 19, 50, 36, 26, 26, 41, 19, 48, 71, 37, 72, 22, 42, 54, 33, 20, 63, 56, 30, 44, 44, 49, 60, 45, 63, 14, 44, 40, 66, 36, 22, 46, 13, 42, 27, 9, 63, 48, 73, 38, 32, 9, 28, 60, 53, 50, 39, 36, 51, 37, 59, 49, 53, 37, 44, 48, 42, 29, 65, 37, 54, 35, 22, 10, 40, 36, 35, 25, 43, 59, 4, 33, 18, 23, 50, 33, 60, 48, 27, 18, 47, 55, 51, 63, 45, 56, 50, 57, 44, 22, 55, 34, 48, 43, 39, 27, 41, 31, 33, 21, 27, 34, 29, 37, 27, 48, 44, 55, 55, 33, 51, 52, 70, 51, 29, 71, 42, 51, 49, 27, 35, 36, 38, 43, 38, 59, 50, 52, 33, 54, 62, 28, 41, 23, 44, 25, 21, 61, 54, 35, 19, 54, 31, 38, 21, 50, 46, 26, 47, 46, 32, 48, 48, 39, 37, 24, 33, 19, 51, 34, 51, 27, 56, 35, 34, 33, 57, 33, 10, 48, 30, 49, 61, 37, 70, 40, 35, 35, 30, 27, 52, 38, 52, 57, 36, 43, 15, 27, 50, 55, 14, 37, 40, 71, 69, 26, 43, 31, 47, 43, 41, 44, 24, 17, 29, 64, 26, 27, 82, 17, 35, 53, 16, 22, 20, 34, 52, 32, 50, 51, 17, 28, 34, 42, 58, 23, 28, 30, 69, 37, 57, 52, 41, 29, 40, 58, 63, 66, 24, 39, 88, 44, 50, 31, 15, 51, 68, 24, 34, 34, 37, 51, 27, 64, 34, 50, 40, 43, 42, 47, 39, 30, 23, 23, 23, 51, 39, 27, 46, 64, 49, 50, 15, 15, 31, 29, 33, 50, 52, 24, 45, 41, 52, 61, 30, 40, 34, 51, 46, 36, 17, 50, 27, 47, 52, 54, 23, 64, 48, 40, 57, 11, 49, 29, 23, 62, 43, 66, 24, 16, 57, 10, 16, 20, 57, 23, 52, 34, 46, 29, 57, 48, 37, 45, 13, 47, 41, 42, 45, 65, 18, 50, 43, 40, 52, 49, 52, 29, 43, 37, 57, 79, 45, 51, 68, 33, 36, 30, 42, 37, 66, 40, 42, 44, 34, 59, 36, 34, 26, 44, 32, 36, 53, 44, 50, 24, 32, 13, 33, 23, 33, 35, 32, 49, 38, 54, 17, 39, 20, 45, 77, 53, 69, 22, 56, 50, 10, 44, 38, 56, 62, 35, 47, 65, 37, 58, 38, 31, 57, 22, 46, 19, 21, 55, 53, 39, 29, 45, 26, 49, 40, 41, 34, 36, 10, 51, 49, 40, 34, 16, 51, 26, 51, 24, 36, 42, 45, 56, 30, 36, 42, 22, 27, 32, 45, 50, 43, 61, 33, 56, 38, 38, 48, 37, 31, 14, 37, 17, 13, 37, 55, 13, 56, 34, 43, 33, 23, 29, 48, 51, 32, 18, 41, 32, 37, 53, 36, 49, 22, 38, 40, 28, 62, 43, 42, 40, 31, 36, 58, 29, 44, 35, 46, 37, 42, 43, 39, 53, 37, 35, 31, 42, 20, 24, 52, 37, 42, 66, 43, 12, 61, 17, 46, 34, 14, 45, 22, 22, 44, 15, 29, 51, 43, 50, 31, 30, 42, 45, 39, 55, 35, 50, 45, 66, 43, 54, 47, 45, 30, 37, 39, 24, 26, 34, 47, 42, 38, 64, 32, 28, 32, 33, 32, 36, 36, 27, 23, 62, 29, 62, 48, 39, 27, 58, 33, 35, 58, 50, 29, 24, 34, 69, 28, 19, 29, 26, 28, 28, 46, 79, 40, 61, 81, 66, 63, 68, 47, 24, 52, 17, 40, 22, 19, 20, 20, 44, 33, 66, 39, 32, 45, 17, 14, 44, 45, 34, 47, 58, 40, 64, 35, 31, 31, 39, 28, 38, 48, 43, 23, 22, 35, 45, 37, 41, 40, 20, 22, 33, 11, 45, 44, 58, 35, 48, 38, 53, 50, 27, 34, 23, 40, 39, 55, 70, 40, 17, 51, 28, 22, 34, 24, 21, 61, 50, 44, 64, 26, 58, 23, 63, 57, 40, 25, 27, 21, 37, 37, 46, 36, 41, 35, 73, 33, 26, 15, 14, 8, 43, 57, 29, 38, 49, 22, 34, 70, 41, 42, 37, 35, 28, 25, 37, 25, 29, 39, 42, 26, 47, 67, 11, 58, 50, 44, 21, 44, 31, 62, 30, 25, 35, 58, 40, 79, 19, 35, 54, 23, 55, 30, 51, 47, 33, 65, 36, 26, 33, 37, 33, 54, 31, 61, 59, 45, 49, 58, 31, 6, 24, 9, 41, 68, 35, 43, 64, 34, 76, 42, 43, 39, 60, 37, 38, 14, 40, 42, 65, 76, 56, 67, 43, 39, 45, 33, 21, 21, 41, 15, 9, 15, 49, 57, 58, 46, 58, 68, 21, 79, 51, 70, 19, 26, 37, 42, 51, 32, 16, 32, 15, 57, 36, 72, 43, 29, 28, 57, 42, 54, 19, 28, 46, 34, 47, 43, 57, 60, 54, 34, 41, 60, 30, 58, 48, 37, 48, 56, 64, 63, 57, 30, 44, 60, 48, 50, 32, 68, 52, 59, 69, 40, 34, 51, 79, 21, 47, 60, 65, 27, 50, 22, 38, 40, 41, 7, 59, 59, 24, 24, 55, 48, 43, 41, 37, 56, 55, 26, 51, 35, 33, 48, 33, 42, 40, 41, 52, 37, 14, 67, 34, 3, 14, 82, 58, 32, 46, 49, 59, 44, 18, 27, 34, 49, 63, 49, 16, 26, 61, 38, 42, 12, 13, 54, 18, 33, 38, 53, 38, 38, 34, 49, 40, 42, 26, 18, 28, 33, 30, 45, 47, 12, 60, 37, 73, 61, 31, 6, 37, 27, 21, 26, 39, 37, 30, 35, 60, 38, 49, 32, 74, 30, 43, 74, 29, 34, 51, 51, 33, 29, 41, 36, 33, 65, 49, 32, 56, 22, 41, 53, 59, 27, 27, 38, 35, 37, 42, 63, 45, 35, 61, 53, 37, 57, 44, 32, 24, 40, 40, 37, 53, 48, 18, 40, 62, 49, 65, 16, 24, 64, 55, 37, 50, 60, 49, 41, 70, 50, 41, 26, 46, 41, 30, 43, 40, 32, 41, 31, 31, 20, 41, 28, 22, 59, 36, 38, 42, 38, 16, 59, 52, 49, 26, 34, 43, 24, 20, 48, 39, 14, 25, 24, 29, 43, 37, 50, 20, 43, 71, 53, 39, 52, 29, 35, 55, 43, 30, 70, 16, 49, 59, 44, 47, 34, 56, 53, 29, 41, 46, 40, 39, 28, 23, 26, 36, 61, 41, 38, 46, 49, 34, 36, 14, 34, 48, 21, 33, 22, 35, 51, 35, 14, 54, 53, 41, 52, 48, 39, 36, 44, 36, 41, 45, 56, 32, 21, 64, 48, 24, 32, 29, 33, 34, 38, 41, 54, 33, 27, 29, 59, 43, 37, 27, 50, 25, 38, 23, 61, 47, 48, 60, 45, 30, 14, 35, 57, 39, 29, 40, 32, 40, 43, 47, 33, 47, 42, 34, 50, 23, 24, 26, 31, 28, 49, 30, 56, 9, 30, 30, 45, 17, 54, 58, 16, 17, 39, 32, 53, 38, 23, 46, 33, 12, 39, 31, 44, 46, 62, 35, 68, 45, 54, 47, 30, 50, 43, 60, 44, 12, 50, 28, 60, 66, 45, 38, 50, 31, 26, 40, 25, 25, 31, 54, 50, 53, 23, 18, 54, 53, 49, 66, 52, 12, 28, 60, 25, 54, 72, 48, 33, 46, 44, 44, 37, 54, 63, 33, 41, 32, 43, 35, 79, 52, 41, 68, 22, 53, 29, 31, 43, 43, 63, 37, 44, 43, 17, 36, 34, 58, 54, 54, 26, 27, 26, 49, 22, 51, 39, 57, 31, 32, 8, 44, 16, 23, 30, 51, 27, 54, 37, 32, 55, 41, 25, 39, 54, 15, 22, 47, 34, 61, 27, 53, 45, 44, 35, 41, 52, 42, 39, 45, 65, 61, 67, 43, 40, 38, 43, 44, 31, 35, 63, 57, 47, 28, 21, 36, 57, 54, 52, 32, 53, 23, 62, 22, 33, 32, 48, 39, 43, 20, 49, 51, 54, 46, 31, 41, 12, 49, 20, 36, 37, 62, 32, 33, 31, 34, 52, 35, 62, 24, 50, 52, 25, 8, 31, 22, 60, 52, 33, 57, 63, 59, 42, 28, 50, 25, 35, 56, 70, 65, 64, 46, 55, 16, 21, 44, 51, 39, 62, 46, 50, 53, 26, 24, 32, 26, 62, 17, 36, 55, 42, 50, 44, 43, 45, 22, 19, 62, 18, 35, 56, 27, 47, 42, 47, 7, 42, 29, 49, 50, 52, 42, 17, 53, 41, 53, 42, 45, 54, 63, 56, 23, 57, 45, 34, 29, 34, 14, 38, 42, 38, 43, 57, 32, 23, 42, 25, 16, 28, 39, 30, 54, 36, 32, 52, 83, 80, 35, 19, 23, 23, 34, 20, 46, 20, 57, 52, 34, 50, 48, 40, 51, 51, 65, 37, 8, 43, 40, 35, 38, 61, 22, 41, 56, 62, 30, 51, 29, 29, 51, 35, 39, 39, 28, 18, 53, 22, 47, 5, 30, 34, 30, 71, 57, 44, 58, 43, 56, 36, 38, 24, 33, 43, 28, 51, 36, 43, 68, 37, 49, 41, 9, 33, 42, 68, 45, 24, 50, 67, 47, 66, 50, 43, 15, 69, 42, 25, 48, 65, 37, 42, 65, 31, 45, 27, 34, 41, 68, 40, 21, 33, 19, 51, 39, 15, 19, 48, 53, 40, 83, 8, 50, 59, 47, 52, 60, 43, 57, 37, 49, 45, 52, 57, 10, 53, 25, 32, 58, 40, 33, 44, 32, 36, 44, 39, 19, 40, 54, 21, 48, 51, 37, 58, 14, 40, 55, 74, 37, 33, 30, 39, 72, 40, 34, 15, 34, 60, 55, 42, 38, 44, 51, 43, 12, 44, 43, 46, 15, 73, 37, 25, 9, 67, 30, 39, 59, 36, 19, 57, 31, 29, 36, 23, 13, 32, 50, 25, 39, 57, 48, 28, 45, 52, 31, 37, 53, 33, 47, 24, 33, 36, 62, 38, 29, 80, 27, 54, 42, 27, 61, 48, 13, 61, 53, 46, 19, 28, 42, 49, 43, 50, 34, 35, 17, 24, 44, 57, 17, 15, 21, 45, 25, 40, 38, 27, 31, 35, 46, 23, 25, 31, 61, 19, 38, 50, 29, 34, 36, 55, 34, 48, 68, 37, 37, 80, 26, 31, 23, 52, 26, 42, 20, 22, 61, 20, 42, 28, 34, 51, 38, 71, 60, 39, 39, 27, 34, 37, 14, 50, 38, 58, 55, 43, 20, 33, 44, 39, 32, 12, 35, 36, 53, 23, 23, 29, 14, 45, 53, 53, 61, 22, 78, 39, 46, 40, 60, 64, 39, 32, 32, 43, 13, 40, 15, 36, 55, 67, 39, 15, 29, 29, 56, 44, 66, 43, 50, 31, 40, 37, 54, 39, 42, 40, 25, 17, 32, 38, 59, 38, 26, 28, 7, 28, 60, 24, 36, 41, 45, 41, 22, 43, 40, 26, 24, 44, 39, 21, 38, 44, 44, 51, 25, 65, 59, 34, 27, 47, 43, 45, 14, 42, 20, 31, 16, 31, 35, 36, 45, 52, 48, 32, 40, 58, 27, 30, 23, 53, 25, 48, 35, 75, 13, 36, 38, 39, 49, 69, 20, 41, 58, 26, 45, 48, 17, 29, 49, 38, 27, 45, 17, 40, 68, 16, 17, 41, 50, 26, 20, 28, 36, 23, 27, 39, 46, 25, 24, 47, 60, 44, 47, 29, 25, 58, 36, 39, 53, 33, 35, 48, 41, 39, 34, 16, 64, 50, 45, 53, 16, 37, 59, 51, 50, 30, 59, 20, 15, 39, 65, 40, 25, 36, 53, 40, 57, 42, 48, 66, 26, 51, 25, 41, 75, 54, 34, 52, 15, 56, 41, 49, 42, 26, 26, 33, 64, 46, 45, 14, 33, 60, 26, 59, 58, 53, 27, 51, 15, 41, 10, 33, 22, 31, 48, 21, 51, 27, 18, 37, 49, 51, 37, 68, 21, 35, 69, 42, 29, 41, 34, 64, 15, 28, 35, 38, 50, 50, 34, 62, 59, 27, 53, 23, 43, 48, 33, 15, 55, 40, 54, 37, 34, 31, 26, 50, 28, 44, 22, 59, 43, 40, 47, 34, 61, 34, 44, 42, 54, 57, 50, 46, 37, 21, 26, 39, 61, 33, 37, 45, 28, 44, 20, 50, 24, 40, 36, 44, 44, 44, 22, 73, 49, 18, 16, 39, 61, 31, 48, 20, 27, 59, 31, 45, 43, 32, 46, 29, 46, 16, 28, 35, 45, 42, 32, 29, 69, 35, 43, 25, 56, 53, 31, 34, 21, 60, 30, 59, 41, 42, 59, 49, 37, 30, 28, 61, 17, 52, 23, 33, 34, 36, 19, 45, 46, 27, 25, 33, 38, 50, 24, 19, 34, 51, 35, 38, 33, 36, 34, 25, 34, 33, 39, 20, 56, 30, 26, 27, 42, 65, 42, 55, 38, 38, 43, 45, 43, 9, 51, 58, 34, 39, 64, 42, 20, 47, 26, 26, 22, 47, 46, 41, 49, 19, 46, 73, 41, 32, 19, 57, 65, 22, 17, 26, 26, 46, 66, 47, 61, 70, 38, 42, 56, 34, 36, 52, 34, 59, 66, 69, 58, 29, 48, 21, 48, 50, 28, 42, 30, 55, 42, 39, 69, 50, 76, 55, 54, 40, 58, 39, 54, 31, 39, 50, 32, 49, 45, 61, 39, 38, 45, 49, 52, 43, 27, 19, 59, 35, 23, 55, 34, 32, 61, 22, 33, 51, 23, 17, 52, 62, 59, 54, 48, 24, 27, 22, 58, 28, 29, 7, 33, 60, 50, 56, 10, 11, 42, 35, 56, 53, 18, 37, 24, 70, 28, 35, 35, 13, 23, 46, 19, 29, 52, 49, 55, 45, 28, 47, 37, 40, 42, 67, 28, 37, 16, 27, 43, 41, 40, 54, 60, 38, 45, 65, 21, 33, 55, 34, 44, 29, 45, 34, 65, 60, 10, 44, 28, 21, 53, 54, 48, 41, 34, 41, 32, 42, 18, 31, 22, 45, 54, 44, 49, 22, 37, 41, 59, 32, 35, 37, 38, 66, 49, 53, 30, 31, 18, 49, 14, 56, 40, 27, 18, 16, 16, 31, 66, 46, 41, 21, 54, 51, 51, 42, 43, 31, 36, 32, 17, 35, 30, 29, 38, 47, 32, 13, 57, 45, 35, 60, 38]}, 'test_1': {'capacity': 100, 'num_items': 5000, 'items': [42, 57, 41, 42, 43, 30, 26, 21, 42, 24, 37, 52, 50, 32, 76, 58, 69, 35, 30, 42, 40, 28, 63, 60, 42, 46, 38, 39, 45, 43, 53, 72, 26, 41, 39, 19, 63, 43, 32, 29, 48, 33, 29, 17, 44, 13, 57, 48, 12, 60, 51, 27, 55, 40, 22, 63, 37, 53, 34, 25, 41, 54, 36, 46, 43, 44, 41, 42, 20, 35, 31, 32, 72, 36, 20, 26, 26, 65, 48, 31, 71, 43, 46, 36, 33, 52, 32, 35, 56, 35, 29, 36, 61, 50, 66, 36, 29, 13, 60, 43, 40, 66, 49, 28, 48, 23, 35, 55, 84, 50, 50, 39, 33, 45, 42, 40, 27, 26, 21, 54, 30, 59, 18, 41, 52, 8, 19, 64, 41, 38, 50, 53, 65, 20, 15, 18, 36, 27, 27, 30, 43, 10, 33, 55, 26, 28, 48, 50, 36, 43, 39, 42, 48, 8, 46, 21, 15, 59, 33, 41, 40, 46, 44, 33, 42, 30, 32, 57, 30, 32, 30, 30, 41, 77, 49, 14, 54, 56, 68, 53, 24, 31, 29, 43, 22, 16, 26, 47, 18, 46, 29, 13, 47, 33, 44, 40, 60, 22, 66, 55, 37, 41, 37, 32, 37, 53, 77, 42, 28, 35, 32, 28, 27, 63, 36, 38, 61, 40, 17, 66, 53, 45, 55, 24, 3, 45, 53, 43, 59, 70, 45, 33, 68, 44, 39, 64, 56, 27, 42, 24, 54, 61, 51, 34, 58, 44, 44, 45, 56, 38, 40, 14, 57, 51, 25, 15, 35, 57, 51, 45, 16, 30, 29, 31, 45, 35, 47, 20, 20, 20, 34, 57, 61, 37, 34, 23, 31, 40, 46, 49, 59, 41, 39, 42, 23, 44, 29, 32, 31, 35, 19, 20, 54, 12, 35, 53, 40, 70, 39, 31, 43, 38, 28, 33, 38, 50, 33, 19, 30, 60, 45, 30, 43, 39, 47, 40, 33, 32, 15, 26, 53, 51, 63, 27, 55, 34, 56, 26, 56, 52, 42, 45, 39, 35, 65, 47, 33, 26, 50, 63, 24, 32, 34, 24, 47, 51, 66, 45, 42, 30, 49, 57, 40, 21, 21, 43, 31, 42, 33, 11, 75, 46, 40, 43, 34, 43, 38, 56, 42, 28, 51, 27, 44, 51, 28, 53, 41, 27, 27, 36, 50, 48, 56, 68, 28, 45, 54, 56, 33, 49, 26, 29, 33, 30, 53, 39, 26, 51, 19, 39, 27, 29, 56, 32, 40, 55, 40, 21, 32, 32, 19, 18, 54, 41, 27, 46, 43, 31, 17, 46, 31, 39, 39, 56, 34, 40, 23, 32, 28, 38, 21, 50, 51, 21, 37, 28, 35, 34, 48, 10, 45, 46, 62, 10, 24, 56, 60, 46, 54, 42, 47, 40, 20, 58, 45, 41, 16, 25, 72, 58, 42, 55, 36, 39, 31, 34, 6, 53, 52, 31, 46, 43, 24, 78, 56, 12, 43, 30, 59, 38, 48, 32, 11, 33, 36, 22, 53, 34, 70, 45, 40, 38, 30, 31, 70, 46, 20, 72, 35, 22, 32, 39, 44, 58, 34, 32, 41, 81, 52, 62, 27, 50, 29, 51, 40, 37, 48, 50, 48, 45, 9, 16, 33, 42, 50, 66, 16, 12, 77, 21, 58, 22, 38, 12, 27, 57, 19, 61, 41, 33, 25, 35, 61, 60, 66, 22, 56, 59, 34, 35, 38, 53, 53, 40, 36, 13, 27, 25, 35, 35, 66, 41, 64, 47, 62, 50, 36, 48, 33, 41, 39, 45, 49, 35, 63, 37, 16, 42, 35, 45, 24, 48, 35, 48, 21, 14, 22, 63, 26, 23, 40, 59, 48, 58, 44, 32, 69, 72, 41, 41, 51, 15, 29, 22, 42, 49, 40, 35, 48, 18, 29, 23, 25, 28, 54, 19, 13, 67, 37, 43, 31, 13, 46, 30, 29, 47, 48, 46, 49, 31, 38, 40, 54, 39, 49, 49, 50, 16, 20, 33, 46, 59, 33, 46, 49, 36, 41, 32, 44, 52, 49, 76, 32, 42, 45, 52, 47, 38, 21, 49, 22, 63, 35, 34, 51, 42, 73, 30, 62, 55, 25, 56, 51, 48, 49, 51, 52, 24, 55, 50, 25, 17, 30, 31, 33, 25, 47, 29, 38, 16, 28, 35, 51, 40, 4, 52, 15, 30, 27, 41, 43, 72, 21, 52, 47, 22, 51, 71, 29, 62, 38, 26, 64, 19, 32, 49, 39, 47, 56, 39, 51, 36, 51, 36, 57, 79, 41, 40, 47, 30, 31, 54, 45, 16, 22, 40, 46, 23, 27, 53, 53, 33, 19, 9, 11, 56, 45, 34, 37, 53, 50, 36, 48, 49, 40, 49, 32, 45, 19, 48, 33, 33, 36, 52, 32, 50, 27, 31, 19, 30, 21, 54, 68, 64, 28, 56, 8, 55, 34, 22, 54, 30, 60, 37, 29, 18, 20, 10, 17, 19, 27, 41, 35, 34, 55, 28, 51, 35, 22, 47, 41, 44, 46, 28, 20, 22, 28, 47, 50, 86, 43, 50, 20, 13, 55, 54, 45, 50, 51, 21, 53, 42, 45, 46, 39, 48, 47, 35, 14, 29, 29, 56, 57, 51, 42, 21, 40, 26, 55, 41, 32, 37, 16, 58, 52, 42, 58, 35, 61, 38, 15, 54, 8, 44, 47, 30, 69, 36, 42, 27, 28, 45, 45, 68, 18, 50, 55, 21, 32, 36, 33, 48, 29, 42, 23, 65, 37, 31, 25, 37, 52, 39, 11, 26, 51, 80, 35, 37, 40, 40, 31, 67, 35, 36, 41, 72, 34, 64, 17, 35, 44, 22, 37, 67, 49, 65, 53, 52, 40, 34, 35, 22, 43, 17, 43, 56, 46, 31, 16, 39, 39, 47, 58, 47, 43, 32, 18, 42, 48, 61, 46, 37, 46, 61, 57, 41, 29, 34, 17, 53, 18, 51, 44, 38, 55, 44, 59, 32, 64, 19, 30, 12, 34, 45, 35, 26, 20, 33, 9, 12, 52, 29, 23, 28, 28, 59, 34, 30, 51, 45, 9, 22, 34, 33, 17, 29, 45, 13, 15, 24, 51, 24, 48, 27, 33, 53, 28, 16, 34, 35, 37, 11, 57, 17, 59, 30, 36, 60, 69, 48, 33, 32, 35, 50, 29, 34, 55, 12, 28, 12, 42, 33, 50, 62, 14, 61, 50, 43, 56, 22, 45, 32, 26, 63, 19, 6, 24, 28, 25, 31, 38, 48, 73, 49, 29, 16, 37, 50, 54, 56, 19, 61, 47, 31, 28, 42, 66, 45, 75, 55, 27, 13, 16, 49, 26, 28, 66, 24, 35, 59, 38, 47, 23, 19, 34, 30, 49, 36, 48, 25, 5, 27, 46, 46, 22, 54, 9, 61, 17, 41, 43, 34, 29, 56, 44, 38, 36, 23, 31, 60, 44, 23, 38, 33, 20, 28, 28, 56, 45, 25, 40, 51, 55, 38, 36, 48, 45, 62, 66, 58, 30, 36, 40, 55, 36, 51, 57, 24, 49, 32, 29, 26, 45, 33, 39, 36, 55, 21, 17, 23, 38, 26, 72, 48, 46, 40, 58, 36, 39, 45, 31, 31, 48, 69, 22, 18, 65, 47, 56, 51, 32, 37, 29, 30, 38, 32, 30, 34, 34, 38, 46, 35, 33, 28, 54, 53, 78, 35, 60, 48, 32, 22, 35, 47, 20, 24, 20, 35, 50, 36, 58, 29, 40, 45, 22, 20, 27, 77, 24, 40, 31, 45, 50, 57, 47, 42, 34, 42, 48, 64, 43, 35, 44, 21, 26, 48, 32, 32, 22, 38, 30, 35, 40, 64, 32, 49, 28, 15, 43, 54, 22, 61, 45, 45, 39, 48, 39, 74, 52, 55, 50, 51, 42, 32, 29, 28, 13, 42, 39, 53, 48, 35, 45, 31, 38, 39, 26, 54, 23, 45, 30, 58, 31, 29, 47, 19, 74, 22, 41, 20, 70, 25, 32, 62, 16, 22, 64, 17, 50, 24, 49, 33, 20, 54, 15, 32, 67, 57, 38, 65, 35, 50, 55, 51, 23, 65, 31, 53, 36, 34, 49, 65, 32, 62, 33, 49, 52, 33, 47, 29, 36, 45, 24, 44, 30, 71, 32, 37, 36, 48, 48, 23, 36, 55, 23, 30, 37, 30, 48, 22, 39, 25, 27, 49, 34, 28, 33, 52, 55, 36, 60, 29, 44, 52, 48, 55, 16, 51, 41, 35, 30, 48, 33, 55, 24, 56, 50, 36, 49, 15, 37, 64, 56, 41, 15, 38, 21, 31, 61, 54, 32, 52, 41, 65, 41, 53, 37, 35, 23, 56, 40, 53, 11, 34, 53, 27, 48, 47, 80, 20, 57, 64, 44, 56, 26, 10, 31, 21, 32, 19, 26, 42, 27, 43, 59, 20, 70, 47, 17, 42, 13, 40, 45, 13, 47, 32, 42, 39, 63, 22, 30, 67, 63, 65, 37, 32, 53, 36, 43, 50, 12, 37, 39, 29, 35, 41, 40, 44, 50, 62, 33, 49, 43, 27, 46, 43, 13, 49, 49, 19, 42, 34, 44, 61, 59, 27, 30, 33, 45, 20, 21, 66, 47, 51, 49, 49, 32, 20, 74, 33, 66, 49, 45, 33, 29, 32, 18, 7, 37, 64, 43, 65, 25, 35, 45, 30, 31, 58, 29, 20, 9, 35, 13, 26, 41, 24, 50, 20, 64, 39, 35, 68, 40, 54, 48, 48, 67, 43, 51, 38, 35, 50, 65, 30, 46, 64, 27, 7, 46, 68, 53, 37, 66, 37, 3, 65, 50, 38, 31, 32, 29, 64, 34, 21, 32, 47, 27, 38, 31, 50, 54, 55, 34, 30, 24, 37, 42, 26, 24, 30, 46, 54, 29, 34, 39, 36, 16, 57, 50, 25, 21, 37, 43, 39, 40, 49, 44, 46, 13, 28, 41, 62, 32, 36, 30, 56, 37, 38, 72, 6, 47, 39, 37, 74, 36, 53, 31, 34, 28, 27, 47, 45, 54, 23, 50, 28, 49, 43, 45, 65, 21, 17, 35, 21, 16, 20, 47, 17, 45, 29, 24, 61, 50, 28, 26, 46, 18, 40, 27, 42, 46, 48, 24, 36, 23, 61, 55, 62, 56, 28, 36, 73, 61, 48, 41, 6, 18, 46, 48, 38, 48, 68, 26, 41, 28, 54, 36, 58, 27, 49, 40, 16, 44, 69, 36, 23, 35, 45, 55, 58, 39, 24, 43, 32, 45, 46, 50, 30, 44, 61, 57, 37, 45, 72, 33, 30, 50, 28, 23, 26, 36, 51, 36, 44, 37, 27, 38, 29, 47, 55, 27, 31, 17, 36, 53, 74, 44, 47, 36, 37, 35, 54, 26, 52, 34, 31, 49, 61, 27, 31, 29, 21, 47, 69, 49, 27, 49, 44, 41, 60, 57, 48, 48, 65, 50, 41, 53, 26, 47, 38, 22, 18, 44, 23, 52, 48, 45, 41, 18, 38, 42, 21, 45, 72, 46, 35, 49, 54, 54, 20, 43, 42, 63, 45, 38, 14, 22, 55, 51, 37, 12, 52, 38, 20, 43, 45, 78, 24, 21, 23, 20, 29, 24, 37, 46, 38, 22, 38, 33, 40, 31, 30, 25, 50, 14, 47, 29, 20, 56, 20, 42, 35, 44, 49, 68, 34, 15, 46, 40, 31, 57, 28, 35, 37, 16, 46, 12, 67, 39, 21, 23, 41, 59, 50, 13, 36, 73, 41, 29, 44, 45, 47, 59, 72, 51, 61, 23, 22, 27, 55, 37, 12, 57, 37, 67, 36, 17, 50, 29, 39, 41, 39, 32, 46, 47, 41, 42, 67, 45, 28, 37, 37, 59, 55, 51, 35, 18, 48, 46, 82, 35, 40, 62, 46, 20, 11, 50, 40, 11, 32, 35, 26, 63, 36, 35, 45, 61, 43, 50, 19, 17, 54, 55, 51, 35, 52, 38, 62, 37, 53, 40, 56, 25, 14, 36, 48, 56, 36, 19, 31, 45, 28, 52, 36, 40, 82, 33, 42, 50, 33, 19, 28, 13, 67, 63, 28, 44, 21, 85, 21, 34, 23, 60, 37, 53, 33, 49, 49, 56, 75, 37, 52, 37, 58, 42, 39, 31, 24, 54, 37, 29, 60, 58, 42, 27, 31, 53, 42, 43, 54, 47, 19, 26, 19, 45, 24, 30, 41, 26, 31, 46, 7, 48, 40, 47, 34, 30, 32, 33, 61, 48, 34, 48, 38, 51, 33, 22, 40, 49, 36, 46, 54, 64, 61, 50, 47, 44, 65, 65, 47, 31, 28, 30, 45, 43, 36, 51, 44, 66, 49, 19, 23, 45, 35, 17, 18, 37, 52, 27, 24, 52, 34, 51, 31, 63, 38, 36, 38, 30, 26, 9, 46, 54, 26, 29, 49, 23, 46, 40, 19, 23, 46, 29, 44, 46, 20, 15, 25, 30, 63, 60, 38, 30, 38, 35, 33, 35, 39, 51, 22, 34, 26, 26, 17, 34, 9, 21, 17, 23, 41, 18, 15, 44, 41, 30, 57, 43, 36, 40, 44, 32, 35, 44, 16, 41, 27, 46, 58, 47, 47, 25, 32, 42, 37, 22, 29, 21, 46, 33, 40, 77, 34, 18, 37, 33, 51, 65, 36, 38, 59, 48, 40, 22, 41, 17, 44, 39, 44, 22, 28, 41, 41, 62, 52, 41, 45, 54, 62, 39, 59, 48, 19, 54, 40, 45, 30, 33, 49, 26, 51, 42, 54, 48, 38, 33, 41, 27, 49, 51, 80, 29, 43, 56, 17, 29, 30, 32, 34, 41, 19, 38, 50, 15, 34, 54, 12, 24, 58, 31, 69, 26, 49, 52, 37, 55, 32, 46, 47, 54, 27, 33, 30, 36, 38, 28, 69, 43, 50, 45, 58, 59, 21, 41, 16, 41, 33, 16, 57, 28, 16, 13, 42, 19, 45, 52, 37, 23, 60, 27, 77, 32, 50, 49, 59, 44, 27, 46, 28, 53, 61, 15, 21, 43, 45, 42, 25, 64, 18, 64, 37, 35, 71, 51, 39, 23, 13, 3, 21, 71, 27, 37, 37, 71, 22, 58, 55, 46, 52, 69, 44, 30, 60, 14, 31, 32, 54, 48, 59, 30, 2, 21, 28, 22, 39, 7, 42, 39, 52, 57, 14, 13, 46, 37, 40, 33, 24, 60, 28, 54, 33, 49, 22, 23, 33, 23, 43, 53, 47, 40, 22, 18, 39, 41, 29, 62, 28, 49, 27, 45, 38, 30, 75, 25, 31, 45, 54, 17, 33, 18, 37, 38, 63, 46, 44, 45, 69, 42, 32, 46, 49, 36, 24, 45, 50, 18, 45, 44, 49, 23, 30, 57, 10, 87, 38, 66, 50, 44, 33, 17, 60, 58, 53, 32, 38, 48, 20, 31, 56, 43, 52, 35, 48, 37, 21, 24, 44, 42, 58, 28, 54, 56, 48, 28, 46, 73, 38, 62, 46, 44, 64, 40, 22, 54, 38, 41, 47, 47, 58, 19, 49, 28, 52, 41, 23, 31, 56, 32, 38, 53, 15, 21, 73, 58, 21, 34, 24, 22, 37, 39, 57, 16, 58, 42, 50, 71, 24, 41, 51, 33, 59, 18, 12, 24, 39, 33, 15, 73, 66, 47, 20, 27, 29, 31, 7, 44, 19, 31, 45, 34, 39, 38, 53, 67, 49, 52, 37, 40, 54, 36, 40, 31, 53, 27, 42, 40, 43, 29, 30, 22, 43, 78, 38, 30, 30, 24, 42, 63, 52, 6, 13, 12, 44, 27, 17, 50, 19, 36, 46, 45, 59, 61, 58, 59, 37, 22, 39, 44, 14, 58, 71, 74, 51, 41, 41, 49, 39, 45, 28, 33, 23, 36, 28, 43, 13, 28, 48, 44, 40, 59, 50, 29, 41, 72, 22, 16, 44, 44, 47, 39, 45, 58, 29, 68, 47, 59, 13, 51, 14, 45, 39, 49, 57, 47, 58, 70, 53, 28, 37, 52, 53, 42, 42, 45, 54, 56, 82, 38, 55, 30, 33, 53, 44, 64, 33, 38, 37, 19, 38, 37, 53, 46, 25, 46, 13, 29, 50, 61, 49, 56, 53, 61, 30, 34, 47, 54, 22, 13, 50, 42, 30, 16, 16, 38, 40, 18, 24, 16, 44, 30, 52, 44, 29, 50, 34, 64, 8, 42, 41, 55, 55, 57, 32, 23, 16, 41, 40, 37, 27, 10, 52, 69, 24, 40, 55, 35, 47, 30, 40, 46, 40, 10, 24, 30, 36, 73, 26, 28, 29, 60, 64, 54, 52, 53, 33, 33, 40, 23, 51, 66, 62, 55, 37, 30, 24, 40, 71, 17, 50, 31, 23, 38, 35, 46, 32, 50, 42, 47, 48, 36, 47, 29, 22, 41, 60, 66, 57, 18, 20, 61, 38, 17, 40, 31, 42, 47, 44, 60, 9, 33, 37, 34, 62, 49, 27, 44, 22, 25, 52, 44, 46, 18, 42, 46, 16, 31, 21, 35, 31, 67, 46, 32, 38, 40, 42, 39, 23, 20, 28, 21, 34, 22, 33, 60, 49, 52, 25, 46, 59, 48, 55, 45, 38, 40, 28, 43, 7, 39, 80, 34, 15, 32, 38, 68, 42, 52, 61, 70, 28, 54, 50, 52, 45, 35, 39, 27, 29, 65, 35, 24, 52, 8, 32, 62, 29, 51, 48, 37, 54, 29, 45, 33, 31, 69, 33, 14, 35, 39, 30, 29, 64, 64, 12, 24, 16, 40, 53, 49, 39, 52, 40, 29, 52, 60, 50, 51, 44, 18, 65, 58, 28, 51, 61, 56, 53, 21, 34, 62, 63, 59, 35, 44, 46, 56, 48, 32, 52, 25, 34, 33, 40, 16, 17, 42, 46, 51, 40, 43, 31, 68, 24, 49, 37, 31, 38, 24, 29, 65, 12, 53, 63, 32, 7, 41, 32, 26, 35, 42, 25, 29, 28, 46, 56, 34, 50, 9, 53, 29, 14, 48, 61, 33, 46, 40, 6, 65, 26, 65, 30, 43, 22, 27, 48, 60, 32, 21, 63, 30, 55, 54, 29, 65, 23, 20, 41, 52, 22, 28, 48, 33, 22, 55, 43, 64, 73, 45, 49, 53, 17, 71, 31, 56, 44, 35, 39, 32, 53, 38, 32, 40, 49, 58, 25, 46, 11, 30, 35, 43, 40, 40, 38, 27, 41, 31, 34, 58, 33, 21, 54, 66, 53, 26, 62, 27, 13, 59, 9, 48, 20, 34, 29, 27, 50, 69, 36, 28, 18, 22, 34, 51, 28, 66, 30, 55, 53, 50, 43, 60, 28, 31, 24, 34, 47, 26, 36, 16, 38, 47, 51, 65, 36, 34, 14, 40, 17, 55, 23, 33, 44, 27, 62, 59, 31, 6, 43, 19, 63, 21, 32, 61, 26, 39, 12, 35, 33, 48, 7, 41, 58, 47, 15, 45, 51, 59, 43, 56, 33, 26, 40, 50, 57, 31, 46, 27, 62, 39, 44, 45, 36, 46, 37, 44, 43, 35, 45, 53, 10, 7, 45, 33, 23, 29, 30, 35, 66, 34, 66, 37, 54, 30, 23, 48, 62, 60, 45, 68, 42, 50, 47, 51, 22, 43, 52, 40, 46, 46, 14, 7, 35, 33, 18, 52, 56, 18, 63, 43, 18, 49, 61, 58, 32, 33, 15, 12, 38, 47, 15, 39, 38, 44, 52, 47, 44, 58, 23, 23, 47, 38, 40, 66, 28, 19, 22, 25, 21, 38, 39, 57, 45, 14, 38, 23, 62, 25, 69, 30, 52, 29, 20, 51, 40, 30, 42, 36, 25, 48, 47, 54, 8, 23, 59, 32, 78, 50, 27, 42, 28, 33, 40, 29, 32, 21, 39, 59, 69, 42, 40, 16, 51, 27, 45, 38, 42, 66, 38, 26, 28, 44, 51, 54, 65, 39, 70, 29, 42, 48, 41, 51, 48, 51, 23, 58, 33, 43, 35, 50, 54, 38, 40, 43, 74, 29, 56, 55, 40, 20, 47, 43, 23, 45, 12, 50, 42, 56, 22, 32, 10, 26, 47, 54, 21, 8, 37, 34, 32, 42, 41, 15, 28, 58, 19, 35, 34, 47, 8, 30, 68, 21, 41, 25, 18, 60, 60, 48, 59, 56, 32, 32, 86, 17, 64, 51, 60, 19, 47, 41, 39, 23, 23, 62, 36, 41, 35, 49, 27, 28, 60, 11, 55, 35, 38, 14, 62, 28, 12, 55, 11, 34, 27, 46, 55, 31, 51, 24, 66, 49, 51, 39, 55, 21, 43, 40, 36, 39, 65, 38, 29, 46, 33, 27, 27, 26, 19, 25, 29, 30, 23, 50, 44, 19, 35, 34, 67, 51, 38, 53, 22, 42, 21, 61, 43, 28, 44, 12, 27, 36, 61, 40, 61, 39, 54, 30, 25, 44, 17, 54, 55, 29, 34, 31, 48, 39, 41, 61, 33, 62, 46, 36, 9, 45, 32, 54, 59, 48, 51, 37, 35, 33, 36, 53, 51, 46, 49, 18, 59, 27, 42, 50, 26, 52, 35, 26, 37, 47, 37, 41, 48, 54, 35, 40, 35, 24, 34, 33, 43, 44, 17, 45, 26, 56, 29, 43, 45, 14, 16, 42, 54, 31, 49, 59, 68, 16, 20, 63, 52, 47, 51, 64, 39, 49, 41, 65, 38, 30, 34, 9, 26, 32, 27, 20, 39, 71, 49, 16, 39, 52, 49, 64, 37, 33, 26, 46, 19, 51, 36, 51, 20, 49, 63, 67, 68, 48, 14, 51, 54, 43, 36, 41, 18, 39, 44, 61, 36, 40, 29, 35, 32, 63, 41, 21, 35, 43, 28, 53, 55, 67, 57, 35, 54, 57, 52, 33, 63, 25, 34, 57, 77, 45, 57, 30, 51, 44, 53, 42, 51, 33, 34, 63, 41, 45, 35, 40, 48, 25, 53, 48, 50, 37, 37, 55, 52, 30, 44, 35, 41, 51, 45, 42, 35, 35, 23, 34, 28, 37, 38, 63, 61, 52, 67, 52, 41, 63, 39, 33, 56, 39, 50, 63, 42, 29, 41, 38, 59, 10, 52, 56, 53, 39, 41, 43, 68, 49, 33, 43, 41, 40, 38, 20, 42, 48, 30, 65, 22, 49, 40, 34, 62, 30, 32, 28, 40, 44, 40, 2, 68, 35, 31, 48, 44, 13, 79, 27, 22, 51, 40, 28, 31, 57, 54, 47, 20, 61, 20, 26, 53, 25, 48, 27, 23, 40, 54, 24, 57, 22, 73, 25, 44, 42, 40, 52, 18, 17, 34, 40, 30, 35, 30, 46, 35, 46, 15, 18, 19, 28, 46, 81, 53, 42, 48, 36, 61, 25, 40, 25, 34, 66, 34, 29, 48, 39, 53, 40, 31, 28, 57, 45, 33, 12, 28, 21, 53, 47, 50, 38, 54, 44, 26, 27, 10, 46, 33, 46, 53, 50, 45, 31, 34, 43, 40, 43, 55, 39, 45, 33, 51, 25, 62, 31, 25, 28, 34, 52, 24, 23, 36, 87, 32, 54, 42, 26, 52, 46, 58, 39, 63, 51, 22, 31, 35, 42, 42, 49, 36, 24, 63, 69, 27, 49, 50, 39, 22, 28, 40, 31, 34, 42, 36, 43, 51, 45, 20, 28, 63, 54, 19, 54, 49, 25, 49, 21, 47, 36, 42, 38, 33, 24, 19, 31, 35, 39, 49, 9, 44, 27, 16, 47, 33, 45, 50, 51, 37, 36, 32, 64, 41, 47, 53, 59, 29, 69, 28, 65, 42, 44, 31, 47, 37, 37, 25, 62, 39, 28, 51, 55, 62, 39, 39, 38, 54, 45, 18, 54, 44, 26, 34, 52, 32, 28, 58, 29, 38, 39, 55, 46, 26, 60, 23, 50, 34, 40, 58, 31, 46, 36, 31, 54, 46, 54, 27, 77, 62, 55, 36, 20, 53, 54, 37, 50, 59, 34, 37, 44, 33, 27, 62, 29, 31, 57, 44, 43, 46, 40, 22, 45, 33, 31, 39, 51, 51, 51, 48, 61, 61, 22, 48, 47, 49, 35, 33, 15, 10, 34, 33, 52, 81, 50, 59, 57, 41, 21, 45, 64, 56, 30, 39, 37, 47, 42, 46, 23, 59, 25, 23, 48, 58, 16, 39, 20, 46, 52, 23, 55, 43, 40, 36, 28, 44, 28, 21, 60, 39, 27, 55, 39, 38, 46, 27, 40, 60, 40, 38, 22, 48, 41, 24, 20, 49, 36, 27, 17, 67, 36, 66, 42, 48, 49, 89, 31, 38, 40, 10, 24, 63, 35, 67, 43, 54, 15, 31, 41, 60, 53, 31, 34, 15, 35, 33, 19, 38, 22, 32, 32, 33, 59, 54, 18, 40, 18, 37, 41, 30, 36, 49, 56, 43, 52, 33, 62, 25, 28, 36, 16, 50, 19, 47, 69, 16, 32, 41, 45, 45, 42, 61, 61, 29, 25, 40, 39, 49, 52, 45, 37, 51, 32, 32, 55, 82, 42, 17, 30, 53, 34, 60, 38, 44, 49, 31, 48, 40, 24, 35, 14, 37, 23, 56, 41, 28, 22, 17, 47, 28, 47, 39, 32, 49, 26, 53, 31, 24, 32, 45, 65, 25, 26, 43, 34, 51, 29, 27, 53, 77, 24, 48, 38, 39, 15, 75, 18, 56, 45, 71, 32, 41, 46, 19, 51, 50, 44, 59, 46, 41, 16, 23, 75, 55, 31, 35, 75, 44, 50, 57, 40, 59, 63, 29, 52, 32, 45, 25, 33, 39, 46, 63, 23, 37, 47, 23, 40, 38, 16, 23, 38, 23, 32, 38, 56, 26, 51, 30, 26, 15, 24, 49, 49, 34, 33, 44, 32, 10, 14, 30, 37, 34, 36, 74, 38, 29, 33, 23, 45, 34, 40, 25, 39, 18, 50, 71, 40, 27, 22, 35, 11, 24, 52, 38, 24, 51, 27, 36, 52, 16, 40, 44, 55, 29, 6, 43, 41, 32, 38, 53, 43, 36, 25, 54, 34, 50, 66, 46, 67, 19, 47, 34, 27, 38, 34, 44, 28, 31, 51, 34, 46, 38, 44, 61, 35, 53, 17, 25, 35, 48, 52, 34, 26, 17, 37, 37, 22, 19, 60, 48, 68, 75, 44, 26, 37, 55, 31, 31, 54, 51, 64, 67, 20, 62, 41, 45, 25, 35, 25, 15, 47, 48, 17, 36, 40, 43, 48, 36, 40, 28, 54, 52, 19, 40, 47, 26, 42, 48, 22, 51, 22, 46, 59, 51, 24, 50, 47, 17, 52, 23, 45, 19, 63, 30, 47, 46, 46, 22, 41, 62, 26, 14, 31, 48, 50, 68, 38, 33, 42, 44, 44, 19, 19, 11, 13, 33, 48, 54, 46, 48, 24, 16, 58, 21, 18, 38, 44, 26, 57, 41, 55, 53, 37, 35, 55, 52, 32, 40, 54, 41, 60, 46, 48, 34, 17, 45, 41, 37, 39, 22, 26, 16, 44, 49, 65, 15, 42, 37, 22, 26, 47, 37, 19, 48, 69, 43, 52, 43, 20, 46, 35, 25, 54, 26, 34, 43, 41, 44, 47, 8, 77, 30, 17, 46, 9, 58, 43, 41, 65, 50, 49, 38, 61, 44, 54, 22, 33, 31, 30, 19, 49, 56, 18, 68, 27, 47, 43, 13, 53, 41, 28, 54, 52, 27, 36, 29, 34, 46, 45, 39, 84, 29, 30, 28, 43, 55, 30, 13, 24, 41, 29, 30, 21, 21, 40, 60, 40, 33, 68, 25, 25, 53, 20, 56, 51, 26, 20, 47, 34, 64, 21, 33, 25, 62, 36, 48, 46, 43, 42, 66, 77, 29, 39, 34, 35, 16, 30, 10, 33, 57, 41, 36, 23, 50, 14, 32, 17, 31, 27, 62, 28, 35, 30, 60, 45, 22, 33, 26, 70, 49, 28, 35, 32, 39, 22, 59, 44, 19, 37, 28, 45, 13, 9, 41, 38, 21, 44, 12, 64, 44, 48, 43, 58, 26, 40, 26, 54, 27, 30, 31, 41, 37, 33, 31, 47, 48, 42, 20, 46, 23, 36, 59, 33, 38, 20, 65, 51, 33, 46, 33, 32, 39, 41, 31, 63, 67, 44, 57, 17, 76, 32, 41, 42, 41, 33, 16, 71, 33, 32, 37, 29, 59, 70, 38, 39, 61, 26, 49, 70, 61, 42, 60, 46, 21, 46, 32, 47, 37, 29, 41, 43, 50, 34, 35, 23, 35, 59, 40, 38, 45, 30, 50, 37, 54, 76, 24, 40, 50, 19, 67, 35, 55, 75, 49, 28, 12, 55, 45, 78, 43, 55, 56, 35, 41, 42, 27, 58, 25, 52, 45, 32, 29, 15, 43, 25, 8, 31, 32, 16, 32, 38, 44, 23, 21, 37, 48, 37, 40, 22, 14, 29, 55, 26, 19, 46, 26, 22, 30, 56, 23, 8, 48, 33, 23, 63, 71, 53, 52, 24, 56, 49, 20, 40, 53, 36, 61, 56, 15, 31, 44, 35, 60, 46, 50, 54, 36, 55, 22, 25, 40, 40, 49, 46, 53, 19, 51, 51, 27, 51, 53, 22, 25, 21, 25, 18, 42, 55, 43, 39, 27, 42, 6, 38, 42, 62, 10, 39, 15, 32, 25, 48, 24, 41, 39, 75, 41, 22, 52, 11, 29, 54, 42, 30, 16, 21, 22, 42, 21, 64, 16, 18, 57, 47, 42, 3, 36, 13, 29, 52, 34, 28, 39, 74, 43, 50, 43, 42, 68, 22, 49, 35, 51, 47, 29, 36, 35, 27, 53, 13, 84, 29, 18, 33, 54, 54, 67, 45, 53, 41, 54, 18, 49, 39, 36, 46, 17, 31, 23, 33, 50, 39, 33, 43, 19, 35, 29, 41, 72, 52, 53, 45, 64, 26, 26, 45, 38, 31, 21, 31, 16, 15, 38, 32, 55, 26, 20, 37, 50, 20, 23, 50, 58, 82, 38, 54, 14, 47, 13, 21, 61, 38, 38, 14, 42, 55, 42, 45, 51, 58, 33, 37, 44, 44, 37, 10, 49, 63, 60, 35, 27, 47, 71, 60, 25, 46, 51, 29, 49, 51, 36, 17, 32, 32, 49, 24, 22, 35, 28, 87, 29, 34, 30, 23, 38, 31, 28, 33, 30, 40, 11, 59, 37, 69, 37, 53, 29, 55, 43, 46, 40, 21, 69, 44, 19, 41, 48, 33, 30, 24, 51, 37, 22, 22, 32, 54, 35, 47, 39, 9, 61, 53, 26, 60, 34, 48, 55, 32, 21, 27, 36, 35, 33, 34, 15, 38, 38, 41, 54, 50, 45, 26, 26, 38, 36, 29, 43, 43, 65, 46, 18, 53, 32, 14, 46, 31, 43, 13, 34, 33, 43, 68, 55, 18, 30, 52, 14, 31, 24, 9, 56, 24, 64, 65, 61, 38, 46, 58, 50, 49, 40, 56, 62, 47, 58, 50, 21, 17, 52, 22, 46, 51, 32, 55, 54, 50, 43, 36, 66, 63, 17, 61, 43, 40, 19, 45, 44, 42, 11, 46, 35, 23, 30, 29, 54, 26, 44, 16, 43, 26, 60, 32, 21, 11, 28, 37, 41, 46, 29, 60, 36, 46, 38, 59, 49, 31, 13, 28, 44, 50, 36, 34, 46, 38, 45, 54, 54, 37, 38, 30, 26, 47, 56, 52, 35, 40, 32, 34, 37, 44, 58, 43, 46, 83, 44, 32, 24, 39, 47, 16, 49, 11, 37, 52, 20, 43, 25, 46, 14, 44, 21, 45, 62, 15, 36, 26, 29, 47, 58, 42, 38, 40, 39, 26, 25, 21, 44, 28, 55, 57, 43, 34, 49, 19, 50, 34, 21, 31, 50, 35, 34, 51, 41, 69, 66, 21, 44, 26, 22, 47, 66, 43, 43, 65, 28, 30, 30, 25, 12, 31, 55, 28, 39, 33, 41, 33, 46, 9, 40, 65, 41, 27, 47, 50, 12, 19, 50, 52, 33, 49, 38, 39, 42, 67, 55, 36, 47, 23, 54, 34, 32]}, 'test_2': {'capacity': 100, 'num_items': 5000, 'items': [20, 47, 39, 29, 7, 45, 45, 18, 39, 48, 15, 25, 33, 40, 52, 32, 33, 30, 11, 57, 15, 44, 22, 23, 83, 19, 34, 17, 14, 34, 50, 36, 52, 62, 48, 68, 40, 33, 27, 18, 25, 37, 39, 46, 35, 50, 60, 66, 52, 32, 31, 25, 62, 38, 54, 31, 58, 34, 20, 42, 57, 19, 21, 30, 21, 29, 20, 47, 43, 31, 34, 70, 19, 27, 17, 61, 53, 20, 69, 37, 32, 40, 49, 47, 26, 55, 52, 62, 41, 53, 17, 16, 42, 43, 49, 41, 41, 38, 25, 41, 42, 28, 14, 40, 50, 47, 16, 26, 38, 46, 35, 39, 77, 14, 55, 51, 43, 41, 23, 27, 60, 60, 38, 14, 31, 54, 23, 44, 44, 32, 32, 27, 24, 40, 51, 8, 46, 29, 10, 48, 65, 31, 55, 13, 23, 50, 28, 13, 38, 60, 27, 32, 22, 25, 45, 54, 38, 35, 23, 60, 77, 77, 24, 27, 28, 45, 17, 54, 45, 55, 42, 32, 42, 67, 55, 33, 57, 41, 35, 16, 35, 36, 45, 23, 24, 34, 35, 37, 48, 57, 57, 46, 47, 51, 59, 60, 42, 31, 63, 40, 31, 37, 11, 20, 49, 51, 33, 49, 53, 31, 51, 44, 39, 30, 41, 17, 43, 51, 33, 17, 39, 42, 38, 52, 55, 46, 55, 45, 58, 43, 59, 40, 42, 5, 45, 31, 28, 36, 52, 53, 48, 47, 9, 38, 45, 27, 34, 38, 47, 51, 34, 44, 40, 14, 67, 56, 30, 25, 42, 37, 21, 31, 69, 51, 46, 45, 55, 26, 58, 45, 50, 58, 44, 66, 27, 23, 28, 50, 39, 74, 30, 12, 24, 18, 27, 40, 55, 59, 58, 37, 29, 17, 17, 37, 21, 16, 41, 17, 39, 33, 42, 30, 60, 31, 32, 23, 32, 28, 17, 60, 24, 36, 29, 25, 81, 43, 44, 51, 51, 46, 28, 32, 36, 57, 39, 32, 31, 46, 35, 25, 70, 46, 50, 53, 50, 35, 49, 30, 33, 64, 41, 25, 29, 47, 26, 61, 54, 64, 29, 35, 35, 58, 47, 26, 58, 8, 66, 41, 64, 52, 22, 34, 38, 17, 14, 44, 33, 24, 36, 56, 49, 29, 35, 23, 15, 49, 79, 42, 36, 18, 50, 32, 27, 44, 36, 50, 51, 24, 83, 48, 35, 33, 37, 14, 32, 33, 34, 38, 40, 63, 31, 41, 51, 34, 71, 56, 37, 46, 52, 62, 36, 35, 57, 43, 26, 36, 43, 53, 17, 66, 39, 23, 42, 39, 17, 53, 57, 32, 44, 32, 44, 30, 53, 32, 41, 22, 38, 39, 15, 22, 45, 46, 59, 35, 31, 14, 37, 38, 24, 33, 53, 29, 39, 37, 61, 36, 47, 37, 29, 25, 47, 42, 31, 41, 59, 55, 28, 44, 49, 50, 33, 41, 51, 43, 32, 58, 55, 38, 49, 38, 36, 40, 54, 72, 53, 51, 42, 47, 49, 48, 57, 52, 33, 27, 33, 28, 41, 22, 48, 25, 50, 23, 41, 36, 54, 55, 25, 53, 26, 8, 47, 44, 48, 26, 8, 50, 39, 44, 68, 44, 70, 50, 44, 52, 39, 64, 41, 64, 52, 38, 16, 20, 11, 41, 25, 29, 35, 37, 17, 21, 46, 40, 32, 25, 14, 57, 29, 31, 20, 32, 48, 70, 48, 20, 61, 57, 25, 59, 35, 80, 27, 26, 54, 45, 54, 50, 46, 23, 48, 31, 40, 27, 43, 24, 48, 61, 36, 41, 41, 31, 42, 55, 49, 48, 37, 20, 35, 45, 37, 11, 32, 54, 50, 4, 24, 61, 48, 63, 38, 43, 38, 27, 20, 52, 22, 11, 38, 53, 27, 43, 26, 40, 47, 38, 42, 56, 52, 72, 53, 40, 25, 50, 43, 49, 32, 55, 25, 51, 37, 41, 56, 47, 37, 57, 29, 27, 60, 34, 42, 61, 46, 31, 38, 54, 48, 34, 55, 59, 38, 43, 22, 27, 28, 29, 30, 53, 60, 16, 55, 13, 39, 29, 28, 44, 42, 53, 60, 33, 48, 48, 44, 40, 57, 50, 59, 28, 31, 65, 23, 27, 44, 46, 57, 36, 60, 23, 23, 58, 51, 47, 15, 57, 50, 33, 14, 42, 44, 19, 24, 42, 40, 51, 37, 33, 50, 39, 38, 28, 31, 49, 55, 68, 42, 81, 21, 38, 55, 49, 39, 31, 36, 59, 62, 62, 79, 36, 55, 57, 23, 24, 32, 18, 53, 34, 70, 32, 38, 40, 43, 41, 35, 30, 53, 24, 47, 38, 36, 30, 52, 28, 67, 58, 23, 29, 33, 21, 54, 42, 44, 41, 33, 52, 35, 42, 39, 44, 50, 34, 53, 29, 50, 26, 8, 41, 39, 25, 48, 34, 45, 30, 35, 38, 57, 65, 34, 33, 47, 28, 42, 62, 42, 12, 31, 51, 13, 51, 47, 28, 76, 54, 34, 66, 18, 51, 32, 27, 48, 46, 15, 36, 43, 58, 35, 32, 41, 43, 16, 52, 22, 70, 19, 34, 25, 45, 27, 41, 33, 43, 47, 43, 62, 29, 62, 56, 33, 23, 72, 66, 44, 28, 29, 16, 20, 55, 53, 48, 59, 44, 44, 39, 14, 42, 40, 47, 67, 28, 51, 19, 44, 42, 41, 50, 12, 47, 37, 38, 11, 31, 51, 25, 29, 5, 22, 32, 51, 44, 56, 61, 43, 16, 50, 38, 20, 62, 70, 31, 37, 30, 69, 46, 13, 19, 45, 20, 10, 42, 34, 64, 56, 10, 35, 41, 32, 34, 48, 61, 55, 37, 49, 40, 26, 42, 35, 44, 41, 62, 29, 34, 34, 41, 54, 55, 35, 34, 37, 30, 29, 36, 62, 35, 38, 45, 31, 35, 37, 43, 38, 48, 45, 43, 28, 50, 49, 42, 64, 29, 75, 47, 60, 30, 55, 56, 62, 48, 35, 36, 22, 43, 56, 30, 37, 41, 21, 31, 60, 56, 15, 38, 32, 53, 25, 26, 36, 65, 40, 30, 42, 54, 47, 10, 11, 36, 61, 31, 53, 33, 21, 58, 42, 39, 43, 83, 44, 26, 25, 52, 10, 30, 29, 45, 30, 56, 39, 12, 38, 56, 33, 29, 31, 42, 36, 25, 24, 44, 54, 43, 48, 29, 38, 57, 50, 21, 67, 42, 28, 38, 22, 68, 11, 38, 15, 28, 58, 47, 24, 43, 50, 27, 17, 38, 20, 39, 53, 34, 61, 37, 57, 30, 20, 33, 65, 43, 44, 65, 38, 38, 15, 69, 49, 40, 30, 41, 14, 45, 43, 27, 56, 30, 45, 53, 39, 72, 32, 35, 15, 48, 18, 66, 54, 58, 44, 40, 40, 48, 25, 33, 62, 38, 43, 38, 20, 21, 29, 45, 35, 41, 61, 48, 25, 42, 36, 25, 34, 51, 39, 46, 53, 68, 21, 26, 18, 49, 49, 12, 29, 29, 46, 63, 38, 32, 49, 67, 28, 39, 19, 42, 55, 44, 44, 29, 26, 29, 33, 24, 22, 22, 57, 55, 29, 19, 34, 59, 43, 45, 37, 58, 80, 28, 76, 39, 51, 20, 32, 55, 34, 43, 65, 14, 60, 41, 33, 30, 35, 38, 51, 37, 49, 33, 43, 34, 21, 91, 9, 67, 41, 52, 24, 45, 35, 38, 35, 33, 37, 52, 42, 37, 45, 24, 44, 38, 32, 47, 38, 47, 65, 73, 31, 47, 46, 29, 70, 35, 36, 19, 34, 59, 46, 23, 31, 31, 21, 33, 32, 32, 43, 43, 23, 66, 52, 20, 35, 51, 47, 23, 58, 40, 44, 43, 12, 75, 41, 31, 35, 30, 48, 34, 28, 47, 43, 53, 37, 57, 36, 37, 45, 41, 60, 34, 33, 41, 17, 26, 67, 63, 46, 69, 29, 46, 27, 51, 38, 39, 47, 33, 31, 58, 38, 32, 53, 39, 41, 44, 20, 15, 23, 52, 44, 46, 49, 40, 13, 46, 25, 52, 48, 44, 29, 70, 42, 41, 19, 36, 54, 28, 48, 42, 34, 64, 13, 22, 46, 60, 58, 65, 52, 46, 38, 56, 36, 52, 18, 41, 64, 59, 41, 47, 20, 64, 15, 33, 72, 45, 36, 51, 47, 39, 38, 30, 58, 78, 56, 47, 38, 53, 36, 21, 62, 57, 37, 46, 54, 14, 36, 58, 67, 42, 41, 37, 31, 30, 55, 59, 46, 42, 31, 42, 22, 24, 62, 36, 52, 44, 54, 30, 24, 61, 19, 49, 63, 52, 57, 42, 9, 66, 17, 54, 23, 40, 27, 59, 53, 45, 48, 42, 22, 22, 42, 51, 47, 30, 40, 26, 34, 50, 47, 33, 37, 27, 31, 45, 61, 34, 40, 36, 29, 59, 34, 56, 38, 24, 32, 51, 47, 26, 22, 69, 25, 58, 25, 57, 11, 45, 15, 54, 34, 52, 16, 47, 29, 54, 18, 29, 32, 66, 43, 51, 37, 59, 46, 35, 19, 44, 43, 35, 18, 36, 59, 36, 33, 42, 42, 48, 35, 36, 5, 19, 35, 39, 63, 25, 44, 42, 41, 61, 52, 37, 42, 37, 48, 51, 65, 41, 30, 29, 25, 44, 48, 74, 19, 22, 40, 28, 45, 35, 44, 35, 46, 27, 41, 75, 42, 19, 27, 39, 50, 19, 49, 32, 38, 71, 50, 24, 45, 31, 33, 23, 45, 32, 30, 60, 33, 25, 25, 34, 14, 46, 37, 38, 30, 34, 31, 49, 62, 42, 33, 39, 49, 23, 65, 27, 29, 81, 59, 54, 43, 31, 56, 23, 59, 65, 44, 50, 59, 45, 32, 41, 29, 11, 14, 25, 37, 22, 37, 44, 62, 44, 28, 53, 9, 49, 44, 34, 49, 67, 51, 37, 26, 45, 28, 24, 57, 31, 54, 16, 36, 32, 22, 28, 19, 24, 39, 69, 46, 22, 39, 58, 45, 41, 23, 26, 60, 35, 50, 43, 35, 57, 32, 19, 45, 10, 42, 36, 15, 78, 40, 57, 21, 33, 56, 51, 15, 67, 26, 25, 64, 38, 36, 39, 43, 30, 35, 34, 44, 29, 29, 18, 32, 40, 68, 46, 24, 40, 48, 31, 40, 19, 36, 45, 57, 17, 18, 31, 31, 31, 25, 53, 42, 34, 21, 48, 30, 7, 56, 48, 25, 32, 52, 44, 32, 55, 57, 59, 63, 48, 33, 9, 12, 44, 42, 50, 44, 37, 56, 57, 26, 42, 27, 49, 31, 24, 14, 31, 51, 26, 15, 27, 37, 37, 57, 30, 53, 41, 12, 57, 42, 27, 31, 40, 18, 56, 22, 37, 48, 30, 35, 36, 37, 32, 35, 49, 35, 34, 38, 26, 57, 60, 46, 32, 50, 37, 41, 36, 45, 47, 40, 45, 29, 18, 40, 53, 52, 42, 33, 26, 44, 32, 39, 60, 43, 60, 24, 44, 75, 55, 27, 32, 19, 20, 42, 21, 41, 41, 47, 34, 46, 55, 38, 35, 49, 36, 45, 34, 22, 41, 68, 31, 12, 36, 27, 52, 46, 26, 15, 37, 59, 26, 52, 38, 35, 54, 13, 48, 46, 55, 57, 39, 52, 35, 44, 52, 24, 51, 41, 59, 53, 36, 38, 62, 44, 58, 18, 41, 44, 44, 26, 38, 35, 42, 49, 52, 37, 33, 46, 56, 42, 44, 47, 63, 24, 47, 69, 31, 32, 11, 23, 46, 43, 53, 65, 56, 17, 54, 29, 36, 38, 54, 33, 37, 53, 46, 30, 46, 28, 30, 41, 31, 23, 49, 35, 33, 62, 43, 44, 30, 18, 52, 57, 38, 42, 30, 42, 44, 44, 39, 46, 50, 44, 27, 61, 29, 31, 33, 41, 68, 49, 36, 13, 32, 62, 41, 59, 39, 24, 12, 57, 53, 31, 66, 19, 47, 47, 51, 60, 21, 41, 50, 49, 31, 26, 64, 26, 48, 29, 4, 35, 48, 51, 52, 33, 23, 26, 60, 44, 55, 23, 44, 41, 47, 52, 26, 13, 75, 12, 53, 43, 54, 40, 57, 36, 17, 33, 49, 25, 54, 10, 34, 43, 28, 37, 48, 31, 25, 54, 22, 70, 55, 39, 57, 39, 14, 39, 20, 57, 39, 35, 42, 40, 35, 30, 70, 24, 43, 42, 28, 43, 13, 32, 19, 42, 53, 63, 31, 44, 19, 41, 29, 51, 30, 61, 45, 43, 47, 65, 56, 53, 23, 27, 54, 39, 56, 47, 50, 54, 49, 51, 15, 35, 32, 68, 41, 76, 16, 43, 36, 23, 40, 43, 12, 30, 56, 57, 47, 18, 31, 53, 22, 47, 21, 39, 47, 43, 29, 51, 29, 39, 36, 54, 24, 30, 62, 36, 70, 16, 46, 24, 15, 26, 20, 42, 55, 29, 57, 59, 30, 47, 60, 37, 43, 43, 27, 42, 55, 26, 12, 16, 45, 42, 57, 39, 22, 37, 38, 41, 38, 46, 22, 10, 51, 32, 38, 41, 17, 17, 28, 35, 43, 25, 51, 35, 45, 67, 42, 18, 41, 35, 77, 30, 20, 46, 46, 43, 44, 41, 50, 29, 45, 26, 31, 41, 32, 44, 31, 58, 26, 30, 66, 14, 55, 30, 19, 48, 55, 53, 15, 64, 32, 43, 21, 40, 78, 37, 29, 46, 29, 25, 40, 67, 32, 53, 29, 48, 28, 48, 26, 70, 53, 52, 47, 19, 22, 44, 49, 48, 29, 55, 44, 30, 55, 32, 50, 51, 45, 63, 71, 28, 13, 26, 48, 34, 43, 49, 39, 38, 69, 14, 32, 38, 50, 48, 37, 50, 33, 52, 28, 39, 46, 37, 30, 28, 28, 32, 35, 24, 38, 33, 36, 52, 37, 27, 32, 15, 41, 36, 53, 23, 33, 11, 43, 48, 32, 50, 35, 69, 31, 39, 10, 22, 18, 40, 21, 8, 39, 39, 32, 28, 35, 61, 47, 28, 41, 61, 71, 39, 37, 42, 55, 46, 23, 42, 64, 28, 33, 22, 65, 26, 35, 26, 23, 22, 53, 51, 50, 22, 50, 49, 28, 15, 48, 58, 53, 51, 44, 25, 26, 59, 47, 51, 25, 21, 40, 32, 26, 35, 68, 34, 17, 59, 63, 29, 22, 27, 8, 21, 49, 43, 46, 28, 53, 43, 16, 58, 56, 56, 38, 41, 53, 51, 58, 50, 52, 31, 44, 26, 36, 52, 38, 14, 31, 40, 24, 52, 58, 37, 56, 43, 62, 58, 25, 55, 30, 40, 60, 26, 23, 26, 61, 18, 43, 43, 47, 21, 38, 51, 33, 60, 39, 40, 40, 58, 38, 43, 31, 49, 28, 20, 48, 36, 42, 28, 36, 22, 62, 19, 52, 28, 47, 51, 58, 56, 32, 29, 75, 55, 32, 40, 34, 47, 57, 49, 32, 41, 20, 25, 38, 42, 30, 53, 24, 25, 53, 42, 17, 29, 21, 44, 46, 33, 32, 54, 35, 48, 30, 66, 43, 44, 71, 66, 46, 57, 64, 9, 41, 22, 39, 45, 43, 33, 26, 46, 41, 34, 32, 66, 18, 40, 22, 52, 29, 73, 31, 36, 36, 50, 26, 56, 62, 19, 76, 43, 39, 55, 39, 44, 58, 15, 27, 16, 47, 35, 50, 23, 58, 57, 44, 53, 48, 24, 63, 20, 39, 40, 39, 30, 38, 32, 44, 29, 43, 30, 49, 45, 45, 42, 69, 16, 26, 57, 36, 37, 56, 47, 15, 57, 64, 36, 50, 42, 39, 9, 45, 14, 36, 33, 34, 47, 32, 52, 26, 41, 33, 19, 43, 15, 25, 55, 59, 33, 33, 32, 44, 56, 67, 84, 33, 42, 44, 61, 47, 24, 71, 29, 22, 36, 33, 41, 19, 36, 24, 51, 36, 29, 26, 26, 35, 28, 38, 49, 58, 35, 47, 31, 43, 30, 23, 19, 29, 33, 50, 44, 71, 13, 20, 22, 31, 44, 62, 23, 25, 31, 24, 48, 25, 58, 32, 31, 37, 34, 63, 56, 16, 59, 51, 25, 30, 69, 32, 39, 50, 55, 28, 37, 87, 35, 70, 52, 33, 41, 47, 9, 52, 55, 32, 59, 47, 79, 35, 55, 12, 25, 24, 36, 18, 52, 34, 28, 56, 20, 35, 24, 40, 61, 42, 61, 29, 29, 30, 64, 45, 22, 45, 28, 45, 30, 46, 47, 33, 25, 34, 43, 53, 41, 20, 43, 60, 49, 46, 55, 50, 32, 45, 33, 62, 14, 57, 54, 35, 26, 58, 36, 52, 68, 29, 56, 30, 13, 38, 22, 30, 33, 52, 35, 63, 42, 50, 44, 23, 52, 37, 17, 56, 49, 44, 50, 50, 48, 37, 52, 35, 43, 46, 12, 52, 45, 34, 36, 22, 46, 51, 50, 33, 34, 35, 25, 28, 71, 33, 34, 10, 19, 20, 42, 39, 73, 37, 39, 30, 43, 40, 15, 55, 35, 32, 49, 51, 41, 55, 42, 44, 46, 20, 44, 61, 46, 55, 34, 27, 32, 33, 41, 56, 33, 63, 7, 34, 7, 36, 36, 50, 15, 30, 45, 29, 39, 62, 30, 66, 37, 40, 61, 35, 25, 64, 20, 38, 29, 17, 23, 41, 42, 50, 49, 45, 27, 28, 46, 69, 24, 57, 34, 43, 22, 34, 19, 30, 21, 11, 62, 47, 44, 50, 37, 39, 32, 33, 10, 56, 39, 17, 35, 57, 42, 55, 41, 30, 38, 27, 44, 28, 31, 36, 52, 17, 12, 37, 47, 48, 20, 55, 47, 38, 62, 48, 41, 48, 46, 22, 59, 37, 39, 30, 39, 32, 19, 51, 33, 61, 52, 46, 47, 34, 32, 44, 41, 42, 64, 23, 31, 48, 62, 19, 50, 34, 40, 21, 43, 19, 31, 57, 37, 52, 69, 49, 45, 28, 35, 23, 21, 35, 27, 41, 58, 8, 20, 41, 37, 46, 26, 45, 21, 39, 54, 21, 41, 41, 26, 58, 16, 69, 49, 26, 30, 32, 63, 51, 30, 74, 42, 36, 46, 31, 54, 24, 27, 21, 62, 30, 41, 34, 62, 59, 21, 40, 22, 29, 69, 31, 17, 36, 44, 36, 65, 49, 52, 52, 22, 51, 35, 55, 28, 43, 28, 45, 28, 48, 49, 47, 41, 34, 60, 28, 45, 32, 77, 44, 36, 25, 58, 17, 50, 51, 39, 40, 9, 52, 21, 15, 41, 34, 49, 57, 28, 21, 47, 26, 68, 47, 13, 54, 49, 26, 63, 34, 52, 35, 28, 7, 46, 63, 17, 20, 32, 27, 42, 17, 55, 50, 14, 33, 45, 36, 15, 10, 46, 25, 41, 49, 67, 20, 27, 49, 28, 36, 68, 37, 34, 59, 44, 55, 34, 69, 51, 56, 36, 30, 63, 60, 84, 48, 44, 44, 47, 34, 58, 45, 39, 23, 33, 39, 85, 64, 56, 42, 46, 43, 35, 32, 55, 28, 46, 23, 58, 28, 31, 54, 52, 31, 48, 35, 50, 24, 35, 54, 13, 10, 23, 51, 38, 24, 53, 3, 18, 34, 55, 54, 23, 42, 54, 12, 36, 50, 39, 43, 29, 38, 36, 41, 40, 36, 32, 29, 46, 37, 69, 36, 36, 50, 40, 28, 21, 45, 42, 16, 49, 50, 36, 37, 24, 30, 32, 29, 36, 20, 57, 16, 25, 53, 49, 23, 51, 40, 22, 59, 32, 45, 40, 31, 44, 39, 26, 29, 38, 60, 41, 71, 39, 37, 20, 26, 39, 32, 40, 45, 43, 67, 32, 45, 53, 29, 54, 36, 41, 33, 24, 57, 51, 55, 40, 64, 25, 27, 20, 18, 31, 43, 18, 24, 30, 25, 48, 53, 18, 39, 37, 54, 25, 35, 31, 35, 34, 30, 44, 12, 45, 31, 44, 38, 17, 50, 31, 31, 37, 42, 43, 33, 35, 22, 26, 48, 47, 33, 58, 29, 53, 31, 27, 66, 6, 60, 46, 36, 27, 66, 54, 57, 71, 5, 12, 42, 42, 15, 28, 43, 71, 21, 53, 48, 33, 27, 55, 14, 51, 34, 17, 53, 30, 32, 37, 59, 39, 29, 64, 50, 48, 51, 32, 28, 29, 32, 49, 18, 58, 49, 46, 35, 50, 40, 48, 33, 27, 35, 51, 38, 51, 57, 14, 78, 34, 18, 33, 33, 35, 45, 34, 40, 12, 25, 53, 56, 27, 31, 40, 27, 48, 68, 48, 29, 42, 19, 38, 53, 33, 19, 54, 17, 27, 42, 69, 60, 37, 65, 57, 55, 65, 48, 42, 76, 23, 26, 64, 52, 55, 6, 27, 26, 29, 30, 26, 64, 50, 59, 54, 58, 34, 47, 42, 50, 55, 53, 24, 28, 21, 51, 39, 56, 37, 49, 37, 56, 37, 58, 49, 39, 61, 40, 41, 19, 50, 65, 50, 53, 45, 54, 20, 30, 29, 27, 53, 37, 56, 24, 37, 54, 46, 18, 11, 43, 19, 34, 22, 27, 29, 35, 48, 56, 48, 53, 27, 38, 39, 26, 33, 15, 62, 28, 56, 43, 31, 15, 45, 50, 23, 49, 27, 57, 25, 36, 32, 54, 60, 38, 33, 28, 32, 49, 34, 14, 27, 58, 20, 21, 23, 43, 38, 29, 52, 78, 41, 63, 50, 38, 36, 39, 65, 36, 38, 61, 59, 47, 45, 17, 57, 24, 69, 74, 23, 50, 32, 35, 55, 42, 54, 47, 29, 52, 42, 27, 12, 60, 11, 33, 28, 48, 38, 25, 45, 59, 28, 61, 42, 33, 29, 27, 64, 20, 27, 15, 56, 15, 64, 34, 41, 27, 77, 52, 51, 36, 40, 43, 59, 23, 19, 49, 44, 47, 45, 37, 38, 39, 31, 35, 41, 18, 55, 38, 60, 38, 20, 52, 21, 26, 49, 73, 35, 29, 32, 29, 17, 47, 31, 38, 36, 31, 33, 22, 14, 17, 44, 72, 54, 58, 32, 49, 29, 28, 50, 62, 42, 35, 30, 22, 35, 29, 40, 43, 42, 50, 33, 42, 61, 42, 40, 34, 44, 30, 15, 64, 48, 35, 25, 44, 41, 53, 26, 46, 61, 38, 20, 39, 63, 24, 34, 52, 17, 30, 41, 45, 40, 55, 56, 27, 44, 31, 23, 24, 52, 39, 24, 51, 46, 60, 27, 52, 34, 62, 22, 48, 58, 38, 39, 60, 72, 24, 51, 51, 12, 48, 7, 20, 19, 46, 27, 45, 21, 31, 34, 35, 50, 6, 40, 45, 47, 42, 37, 24, 66, 43, 39, 40, 64, 30, 48, 9, 47, 47, 59, 40, 34, 46, 33, 45, 44, 49, 34, 56, 48, 31, 39, 58, 62, 30, 24, 42, 28, 59, 57, 61, 38, 60, 35, 23, 46, 46, 40, 44, 43, 38, 34, 51, 49, 49, 39, 37, 21, 74, 48, 80, 39, 30, 23, 53, 48, 42, 20, 44, 35, 53, 34, 52, 14, 32, 73, 36, 24, 41, 42, 46, 39, 35, 40, 18, 14, 34, 27, 38, 54, 28, 29, 41, 71, 18, 48, 41, 32, 34, 13, 37, 24, 23, 38, 47, 42, 47, 53, 38, 31, 9, 37, 59, 33, 29, 67, 9, 27, 44, 53, 13, 29, 38, 52, 32, 31, 22, 54, 43, 42, 20, 32, 43, 17, 60, 17, 38, 40, 25, 67, 50, 40, 16, 72, 41, 43, 12, 47, 10, 34, 31, 28, 43, 63, 55, 42, 17, 31, 62, 53, 19, 22, 28, 46, 42, 29, 76, 17, 21, 41, 31, 32, 42, 43, 43, 24, 36, 59, 5, 60, 37, 18, 46, 9, 48, 53, 51, 60, 40, 21, 9, 19, 38, 44, 32, 41, 30, 43, 52, 26, 20, 46, 37, 40, 54, 40, 36, 10, 29, 54, 56, 19, 35, 59, 33, 42, 39, 32, 50, 31, 33, 57, 15, 32, 34, 41, 55, 43, 55, 59, 41, 69, 32, 34, 21, 34, 32, 43, 55, 27, 28, 49, 22, 34, 37, 36, 39, 58, 42, 45, 50, 14, 39, 56, 46, 73, 21, 29, 37, 34, 56, 55, 37, 44, 49, 40, 51, 64, 64, 62, 60, 10, 43, 34, 43, 20, 31, 44, 41, 40, 29, 57, 68, 47, 44, 28, 27, 34, 53, 49, 48, 38, 51, 25, 15, 31, 28, 42, 50, 37, 33, 38, 24, 36, 29, 38, 65, 48, 60, 40, 40, 42, 10, 36, 36, 46, 64, 45, 38, 51, 20, 45, 39, 38, 44, 12, 61, 27, 44, 62, 50, 69, 57, 58, 53, 31, 56, 29, 39, 21, 35, 40, 29, 36, 28, 56, 15, 55, 59, 50, 46, 8, 38, 54, 15, 46, 29, 59, 56, 52, 33, 34, 74, 34, 38, 43, 25, 37, 42, 40, 64, 58, 31, 28, 47, 21, 60, 54, 62, 70, 27, 44, 17, 25, 35, 7, 58, 6, 68, 39, 37, 4, 44, 30, 41, 12, 42, 24, 31, 24, 58, 48, 37, 38, 44, 43, 45, 42, 31, 17, 41, 52, 55, 45, 24, 5, 56, 73, 25, 30, 36, 59, 24, 46, 18, 57, 30, 31, 34, 40, 61, 46, 49, 40, 44, 45, 20, 43, 33, 42, 38, 54, 10, 39, 42, 40, 12, 48, 36, 32, 33, 43, 38, 28, 28, 18, 61, 27, 23, 37, 51, 31, 30, 46, 22, 32, 27, 36, 44, 79, 45, 50, 44, 6, 33, 28, 31, 15, 36, 54, 43, 51, 51, 21, 57, 21, 24, 17, 53, 38, 41, 37, 18, 21, 27, 43, 42, 20, 18, 55, 21, 36, 43, 26, 38, 46, 44, 50, 27, 19, 45, 45, 39, 25, 56, 27, 45, 55, 36, 37, 30, 30, 27, 38, 44, 52, 30, 48, 42, 29, 27, 24, 14, 38, 18, 38, 52, 36, 17, 37, 53, 59, 61, 12, 27, 36, 24, 16, 22, 31, 55, 45, 54, 45, 51, 29, 32, 33, 46, 30, 49, 51, 47, 71, 52, 33, 12, 36, 39, 33, 53, 43, 32, 76, 39, 25, 31, 28, 14, 40, 70, 35, 30, 51, 44, 47, 39, 48, 43, 33, 37, 12, 34, 62, 46, 36, 44, 25, 69, 36, 24, 13, 34, 45, 28, 47, 27, 58, 14, 36, 45, 36, 35, 20, 55, 14, 29, 50, 50, 33, 28, 24, 38, 26, 68, 55, 20, 33, 47, 56, 67, 48, 39, 37, 50, 51, 29, 20, 34, 33, 53, 45, 28, 51, 50, 39, 53, 50, 58, 46, 43, 16, 31, 50, 71, 40, 41, 66, 40, 33, 38, 48, 52, 11, 28, 29, 49, 56, 23, 46, 51, 58, 49, 33, 47, 28, 41, 51, 25, 45, 41, 28, 39, 54, 41, 28, 26, 35, 33, 56, 45, 39, 27, 40, 48, 25, 40, 51, 51, 33, 32, 41, 10, 41, 55, 43, 26, 28, 50, 46, 29, 35, 19, 27, 28, 55, 36, 57, 64, 44, 34, 34, 32, 26, 30, 36, 20, 40, 6, 37, 33, 49, 68, 45, 34, 54, 52, 48, 65, 37, 35, 32, 48, 41, 48, 32, 43, 26, 41, 35, 41, 62, 35, 26, 45, 31, 30, 37, 23, 68, 40, 16, 28, 28, 24, 39, 46, 12, 40, 45, 44, 35, 53, 38, 42, 27, 32, 39, 53, 18, 30, 45, 58, 42, 36, 67, 24, 36, 38, 9, 56, 61, 47, 60, 58, 66, 14, 35, 32, 32, 58, 38, 40, 37, 38, 44, 57, 34, 75, 44, 33, 29, 53, 44, 32, 40, 35, 55, 13, 35, 52, 31, 47, 16, 35, 56, 39, 33, 46, 47, 24, 46, 21, 35, 35, 17, 31, 39, 39, 36, 17, 29, 42, 33, 29, 54, 56, 24, 28, 48, 15, 44, 35, 35, 39, 60, 42, 48, 43, 58, 36, 46, 30, 45, 40, 63, 42, 15, 54, 34, 30, 54, 34, 21, 19, 25, 21, 19, 47, 28, 58, 28, 11, 29, 36, 30, 56, 31, 38, 29, 48, 36, 34, 45, 35, 39, 55, 10, 31, 72, 44, 31, 44, 34, 15, 39, 5, 35, 35, 50, 66, 45, 50, 47, 40, 20, 22, 50, 34, 46, 55, 44, 55, 62, 38, 46, 45, 52, 27, 51, 33, 29, 16, 40, 37, 62, 37, 46, 26, 37, 47, 26, 39, 36, 35, 31, 48, 19, 41, 56, 44, 54, 67, 36, 27, 39, 31, 46, 19, 50, 29, 48, 28, 52, 49, 30, 39, 53, 54, 20, 29, 48, 40, 44, 49, 53, 19, 23, 33, 32, 47, 36, 42, 38, 24, 13, 52, 45, 52, 46, 59, 18, 31, 37, 35, 22, 26, 9, 12, 20, 36, 10, 41, 31, 48, 42, 44, 29, 38, 53, 27, 50, 46, 64, 22, 30, 37, 24, 50, 52, 32, 43, 51, 78, 70, 62, 34, 58, 27, 61, 27, 54, 59, 48, 42, 58, 67, 50, 24, 42, 30, 29, 36, 52, 53, 27, 20, 38, 9, 29, 17, 34, 26, 8, 32, 52, 27, 31, 35, 31, 23, 50, 24, 41, 67, 44, 69, 21, 30, 58, 33, 32, 44, 53, 41, 41, 40, 15, 48, 56, 39, 37, 59, 20, 61, 38, 44, 23, 28, 32, 54, 29, 33, 46, 42, 63, 58, 47, 37, 32, 12, 39, 46, 13, 56, 68, 49, 59, 35, 23, 13, 47, 27, 69, 4, 49, 35, 60, 41, 5, 28, 67, 51, 42, 45, 28, 36, 42, 52, 50, 46, 36, 35, 17, 33, 20, 23, 53, 38, 39, 43, 29, 37, 55, 44, 32, 35, 20, 63, 51, 39, 50, 30, 27, 80, 18, 53, 54, 51, 53, 39, 32, 63, 10, 31, 32, 39, 38, 44, 30, 37, 40, 44, 43, 30, 20, 44, 58, 70, 65, 54, 47, 40, 54, 36, 46, 48, 54, 31, 29, 47, 48, 27, 46, 24, 40, 50, 28, 50, 31, 19, 50, 61, 37, 36, 47, 25, 67, 31, 38, 19, 39, 25, 14, 76, 34, 52, 22, 55, 47, 20, 39, 34, 54, 40, 44, 59, 48, 41, 50, 29, 25, 42, 64, 38, 23, 55, 27, 40, 47, 24, 34, 66, 31, 56, 10, 46, 43, 45, 30, 48, 15, 28, 43, 50, 16, 35, 28, 45, 40, 38, 48, 16, 26, 30, 26, 30, 68, 67, 53, 44, 45, 51, 47, 45, 29, 45, 46, 46, 75, 21, 28, 30, 35, 44, 45, 42, 48, 33, 52, 49, 53, 39, 36, 25, 49, 45, 17, 20, 61, 18, 29, 68, 50, 47, 28, 41, 26, 36, 40, 16, 46, 26, 38, 37, 59, 56, 18, 57, 33, 65, 44, 42, 37, 55, 38, 46, 8, 16, 51, 27, 51, 54, 27, 12, 10, 48, 70, 19, 39, 39, 28, 36, 23, 33, 32, 31, 24, 7, 37, 21, 31, 36, 46, 21, 51, 61, 54, 24, 36, 74, 40, 49, 25, 40, 46, 19, 28, 44, 58, 10, 34, 43, 45, 30, 36, 48, 33, 50, 43, 50, 35, 16, 40, 36, 38, 35, 54, 37, 40, 42, 14, 35, 41, 47, 51, 50, 61, 36, 58, 30, 46, 44, 38, 20, 11, 34, 42, 59, 38, 71, 40, 25, 35, 52, 26, 66, 49, 36, 31, 24, 52, 58, 60, 7, 31, 49, 35, 61, 56, 46, 32, 19, 78, 35]}, 'test_3': {'capacity': 100, 'num_items': 5000, 'items': [55, 51, 16, 43, 30, 49, 52, 44, 48, 29, 52, 34, 37, 25, 53, 48, 33, 34, 37, 72, 42, 46, 13, 64, 42, 66, 60, 37, 27, 48, 32, 46, 41, 36, 52, 22, 17, 30, 32, 37, 39, 35, 43, 55, 49, 23, 43, 66, 36, 42, 30, 37, 29, 44, 29, 48, 51, 47, 60, 51, 40, 36, 55, 60, 42, 60, 54, 20, 28, 43, 46, 41, 39, 36, 22, 23, 22, 44, 44, 41, 35, 50, 17, 30, 24, 46, 32, 66, 39, 54, 34, 24, 41, 49, 37, 41, 5, 34, 49, 44, 24, 44, 20, 31, 46, 32, 86, 31, 48, 38, 49, 16, 46, 58, 18, 41, 26, 61, 48, 51, 16, 48, 30, 48, 21, 34, 13, 37, 59, 30, 34, 68, 59, 36, 28, 19, 61, 50, 14, 44, 43, 18, 48, 69, 55, 63, 69, 69, 25, 55, 44, 55, 29, 63, 50, 47, 37, 40, 35, 25, 25, 34, 49, 30, 40, 34, 47, 43, 65, 69, 47, 67, 36, 56, 18, 16, 34, 48, 31, 13, 61, 42, 24, 52, 42, 35, 37, 33, 17, 21, 49, 57, 47, 27, 25, 52, 20, 20, 36, 40, 46, 44, 59, 46, 47, 54, 38, 65, 68, 54, 47, 36, 61, 25, 53, 34, 21, 54, 61, 27, 31, 50, 42, 43, 25, 29, 32, 26, 26, 37, 33, 29, 30, 64, 37, 52, 43, 43, 47, 59, 37, 38, 33, 66, 34, 32, 53, 14, 67, 10, 35, 58, 50, 23, 36, 46, 52, 34, 48, 24, 28, 47, 49, 19, 60, 20, 23, 18, 34, 32, 62, 31, 50, 53, 26, 53, 27, 39, 40, 61, 48, 41, 40, 32, 33, 42, 30, 31, 50, 19, 36, 64, 46, 36, 29, 55, 49, 43, 42, 62, 47, 36, 49, 47, 27, 59, 24, 46, 40, 48, 35, 39, 62, 31, 67, 37, 15, 10, 17, 66, 48, 35, 24, 36, 41, 17, 34, 43, 70, 44, 55, 50, 35, 42, 14, 33, 63, 12, 62, 56, 60, 17, 26, 45, 62, 68, 24, 66, 24, 52, 27, 12, 68, 43, 41, 38, 75, 65, 51, 63, 20, 24, 32, 46, 41, 32, 51, 64, 60, 11, 59, 54, 47, 60, 26, 38, 76, 15, 46, 7, 25, 57, 23, 32, 34, 26, 25, 38, 59, 45, 38, 33, 31, 37, 37, 44, 46, 21, 22, 52, 29, 19, 39, 41, 39, 31, 51, 32, 23, 21, 30, 49, 64, 28, 49, 19, 48, 19, 49, 16, 34, 46, 61, 13, 45, 39, 36, 36, 32, 40, 29, 54, 34, 37, 38, 65, 27, 28, 38, 46, 34, 38, 50, 54, 34, 39, 39, 21, 38, 44, 21, 52, 59, 33, 69, 38, 54, 13, 44, 52, 32, 28, 44, 43, 58, 21, 52, 35, 42, 34, 49, 39, 26, 69, 25, 37, 49, 54, 56, 65, 43, 32, 36, 27, 40, 23, 48, 24, 13, 25, 38, 29, 40, 26, 36, 50, 47, 25, 59, 24, 45, 28, 41, 23, 55, 44, 49, 64, 14, 49, 13, 12, 14, 61, 37, 63, 45, 17, 33, 27, 32, 15, 48, 54, 28, 36, 24, 45, 43, 26, 55, 29, 60, 53, 30, 87, 48, 51, 47, 54, 38, 53, 51, 25, 48, 12, 30, 36, 80, 63, 30, 33, 38, 33, 32, 24, 12, 29, 41, 26, 64, 37, 24, 83, 27, 62, 52, 45, 23, 39, 37, 51, 52, 48, 23, 34, 51, 27, 41, 50, 52, 73, 23, 38, 38, 25, 36, 52, 79, 21, 42, 60, 68, 48, 23, 15, 33, 39, 50, 23, 39, 64, 51, 16, 27, 41, 70, 50, 34, 29, 44, 18, 63, 47, 14, 36, 45, 69, 71, 42, 11, 49, 10, 43, 31, 48, 54, 31, 40, 35, 40, 38, 33, 46, 43, 34, 26, 49, 8, 46, 11, 27, 27, 11, 64, 47, 37, 41, 68, 28, 31, 69, 36, 40, 45, 49, 55, 35, 46, 44, 66, 50, 53, 37, 30, 66, 14, 63, 39, 45, 42, 37, 48, 55, 54, 32, 18, 64, 39, 49, 68, 35, 40, 16, 51, 51, 41, 54, 41, 27, 17, 40, 36, 54, 58, 36, 46, 29, 34, 35, 18, 41, 59, 49, 44, 36, 50, 29, 36, 15, 58, 30, 15, 46, 26, 30, 62, 50, 35, 19, 35, 20, 32, 19, 69, 19, 40, 51, 51, 53, 17, 38, 40, 10, 43, 22, 72, 33, 70, 14, 48, 38, 50, 42, 21, 28, 36, 44, 67, 34, 22, 17, 18, 28, 49, 66, 26, 53, 41, 21, 8, 26, 39, 54, 45, 42, 28, 49, 62, 66, 41, 36, 41, 32, 31, 20, 42, 26, 39, 37, 29, 29, 21, 41, 26, 36, 57, 44, 45, 26, 42, 44, 45, 47, 61, 51, 27, 22, 44, 44, 25, 7, 36, 21, 53, 26, 38, 26, 28, 60, 57, 28, 65, 64, 33, 34, 29, 26, 48, 42, 46, 21, 31, 62, 58, 47, 56, 42, 50, 52, 41, 23, 28, 64, 11, 46, 36, 56, 44, 58, 58, 29, 13, 68, 46, 45, 15, 29, 53, 51, 58, 27, 35, 47, 39, 48, 34, 26, 36, 54, 60, 56, 67, 40, 39, 63, 47, 44, 24, 58, 48, 48, 49, 46, 41, 68, 42, 50, 73, 23, 23, 36, 41, 43, 20, 63, 36, 20, 39, 49, 25, 32, 53, 21, 31, 54, 30, 22, 28, 37, 57, 37, 41, 42, 21, 14, 48, 22, 49, 39, 21, 36, 19, 31, 64, 50, 12, 32, 58, 45, 35, 21, 49, 58, 69, 48, 37, 27, 44, 32, 20, 24, 35, 49, 54, 19, 53, 40, 49, 67, 26, 49, 70, 43, 30, 38, 27, 35, 57, 39, 45, 38, 41, 15, 21, 54, 26, 34, 46, 64, 36, 28, 45, 63, 57, 67, 22, 26, 8, 42, 47, 36, 66, 23, 42, 24, 16, 37, 39, 57, 54, 26, 33, 17, 21, 66, 26, 32, 35, 54, 40, 19, 59, 41, 45, 34, 45, 31, 32, 20, 35, 50, 24, 41, 93, 47, 30, 45, 32, 45, 37, 40, 67, 32, 14, 28, 41, 62, 34, 28, 33, 28, 41, 61, 37, 46, 23, 32, 33, 39, 37, 49, 36, 32, 61, 27, 68, 62, 52, 40, 39, 46, 23, 49, 17, 38, 31, 23, 17, 25, 70, 47, 46, 50, 15, 34, 56, 51, 48, 74, 27, 64, 11, 51, 46, 37, 35, 51, 23, 35, 36, 31, 55, 32, 33, 49, 12, 39, 48, 20, 35, 58, 70, 36, 52, 21, 46, 32, 41, 42, 42, 13, 14, 44, 31, 51, 47, 21, 45, 43, 38, 44, 44, 32, 54, 30, 51, 36, 8, 44, 14, 28, 35, 34, 40, 28, 16, 49, 21, 33, 39, 48, 65, 38, 58, 38, 35, 41, 36, 77, 33, 38, 29, 23, 20, 59, 38, 30, 32, 25, 27, 28, 45, 43, 42, 23, 20, 37, 29, 49, 51, 10, 73, 12, 33, 30, 21, 48, 38, 48, 46, 31, 37, 35, 26, 67, 21, 66, 55, 43, 26, 49, 52, 39, 33, 59, 33, 25, 54, 55, 16, 19, 34, 49, 42, 44, 26, 32, 40, 25, 53, 33, 36, 61, 66, 55, 78, 54, 31, 44, 40, 25, 31, 65, 57, 50, 25, 17, 52, 23, 50, 24, 54, 28, 56, 26, 41, 46, 43, 43, 46, 39, 26, 26, 40, 59, 31, 24, 30, 14, 53, 34, 54, 34, 46, 66, 51, 52, 56, 30, 45, 38, 22, 49, 55, 40, 24, 54, 41, 44, 38, 39, 40, 15, 7, 76, 42, 53, 44, 39, 39, 41, 38, 53, 23, 52, 44, 28, 62, 41, 69, 43, 60, 37, 33, 37, 69, 38, 49, 35, 37, 29, 22, 37, 52, 40, 40, 20, 18, 30, 39, 49, 10, 9, 62, 47, 46, 27, 79, 43, 37, 34, 57, 56, 45, 42, 44, 47, 21, 27, 59, 36, 17, 39, 45, 69, 28, 28, 48, 20, 47, 48, 60, 31, 56, 43, 54, 19, 19, 59, 67, 23, 48, 52, 26, 50, 18, 70, 22, 15, 42, 39, 29, 64, 23, 57, 24, 31, 12, 25, 20, 54, 49, 65, 60, 41, 32, 45, 41, 57, 54, 35, 16, 27, 54, 55, 71, 33, 21, 51, 39, 45, 29, 36, 28, 7, 8, 34, 38, 26, 33, 81, 62, 15, 31, 19, 42, 25, 47, 53, 45, 49, 52, 33, 42, 34, 59, 54, 45, 54, 31, 47, 52, 42, 26, 46, 36, 41, 54, 31, 52, 60, 42, 41, 47, 43, 19, 54, 17, 31, 34, 77, 49, 12, 27, 36, 61, 31, 47, 45, 53, 48, 44, 18, 45, 51, 21, 32, 20, 38, 32, 15, 35, 45, 34, 38, 35, 48, 60, 61, 37, 54, 26, 74, 56, 22, 38, 20, 24, 42, 26, 48, 58, 61, 45, 40, 48, 50, 25, 36, 67, 44, 52, 30, 69, 35, 39, 46, 65, 76, 41, 45, 28, 34, 41, 27, 61, 51, 18, 34, 45, 20, 29, 54, 27, 32, 65, 16, 27, 47, 25, 17, 38, 38, 35, 34, 22, 34, 36, 15, 49, 47, 78, 20, 28, 26, 42, 34, 32, 38, 42, 50, 32, 47, 37, 32, 52, 39, 30, 29, 58, 27, 25, 38, 50, 49, 39, 50, 43, 27, 55, 49, 49, 58, 31, 18, 41, 49, 49, 31, 12, 41, 68, 51, 83, 22, 38, 39, 65, 35, 17, 49, 28, 21, 19, 53, 40, 44, 67, 49, 17, 25, 31, 24, 29, 41, 26, 35, 38, 36, 61, 38, 37, 13, 49, 58, 37, 32, 57, 46, 39, 38, 25, 47, 17, 50, 33, 51, 44, 47, 47, 35, 42, 47, 50, 31, 46, 11, 28, 52, 22, 31, 50, 54, 22, 39, 36, 29, 34, 34, 60, 47, 29, 40, 49, 26, 51, 26, 52, 39, 49, 14, 52, 19, 34, 48, 39, 14, 57, 40, 49, 16, 68, 45, 30, 29, 55, 40, 42, 43, 33, 61, 38, 40, 23, 9, 47, 59, 38, 38, 39, 30, 59, 45, 81, 48, 62, 22, 40, 20, 46, 19, 62, 56, 40, 34, 35, 34, 26, 40, 34, 26, 48, 37, 22, 45, 26, 38, 13, 21, 37, 37, 31, 56, 47, 17, 42, 12, 35, 58, 29, 40, 39, 34, 25, 50, 49, 10, 58, 62, 28, 84, 47, 41, 48, 62, 54, 49, 53, 58, 33, 52, 43, 27, 29, 53, 81, 52, 31, 23, 37, 50, 68, 28, 30, 14, 39, 55, 44, 40, 37, 28, 31, 42, 40, 51, 45, 58, 67, 36, 39, 34, 26, 61, 49, 57, 51, 42, 26, 63, 46, 41, 58, 13, 49, 39, 43, 49, 23, 43, 51, 51, 20, 47, 15, 55, 72, 18, 21, 25, 37, 49, 39, 45, 52, 39, 73, 31, 38, 36, 36, 29, 33, 33, 21, 22, 36, 41, 65, 69, 28, 28, 26, 59, 26, 41, 35, 14, 22, 44, 43, 40, 34, 54, 29, 36, 50, 37, 44, 48, 26, 44, 64, 32, 48, 46, 50, 37, 45, 40, 11, 31, 14, 32, 42, 40, 36, 34, 36, 48, 29, 16, 48, 55, 54, 58, 32, 35, 55, 28, 43, 24, 38, 52, 34, 34, 20, 63, 31, 57, 38, 31, 27, 51, 34, 18, 60, 47, 55, 39, 41, 39, 27, 39, 67, 57, 41, 21, 13, 39, 42, 28, 33, 32, 31, 57, 18, 50, 32, 16, 42, 44, 15, 31, 51, 48, 15, 22, 40, 29, 26, 14, 51, 38, 39, 40, 21, 52, 59, 23, 38, 26, 45, 32, 61, 40, 51, 35, 44, 53, 38, 49, 29, 26, 21, 37, 20, 54, 29, 56, 28, 75, 29, 47, 59, 36, 24, 31, 32, 51, 43, 45, 72, 44, 30, 62, 39, 30, 36, 37, 33, 31, 32, 39, 30, 64, 46, 25, 22, 70, 45, 30, 62, 67, 61, 40, 9, 41, 5, 30, 52, 32, 38, 8, 13, 67, 27, 40, 36, 36, 38, 31, 27, 39, 33, 72, 56, 41, 64, 51, 62, 21, 36, 51, 30, 36, 29, 33, 17, 43, 18, 38, 24, 59, 30, 36, 15, 27, 45, 14, 47, 29, 36, 51, 58, 45, 49, 61, 37, 45, 38, 58, 30, 58, 52, 29, 65, 38, 43, 18, 30, 28, 41, 42, 11, 51, 22, 57, 38, 54, 36, 55, 38, 29, 46, 35, 27, 26, 56, 47, 27, 29, 22, 38, 13, 24, 32, 42, 32, 50, 46, 35, 24, 41, 54, 43, 47, 36, 37, 30, 48, 34, 55, 38, 35, 75, 28, 12, 57, 39, 21, 18, 33, 17, 26, 48, 68, 55, 50, 50, 30, 45, 26, 37, 52, 53, 22, 73, 54, 39, 24, 26, 27, 23, 38, 41, 48, 47, 30, 36, 22, 38, 27, 26, 33, 58, 70, 68, 8, 29, 9, 19, 17, 32, 42, 50, 60, 43, 51, 25, 30, 56, 22, 70, 52, 26, 22, 53, 47, 23, 19, 61, 46, 39, 47, 11, 39, 29, 37, 70, 52, 41, 37, 36, 51, 33, 29, 41, 46, 44, 24, 24, 58, 11, 53, 34, 44, 53, 39, 52, 74, 16, 53, 46, 38, 71, 57, 26, 38, 54, 54, 40, 47, 81, 31, 52, 29, 29, 52, 64, 30, 63, 40, 26, 42, 56, 55, 36, 37, 19, 40, 51, 29, 51, 57, 45, 31, 57, 32, 27, 39, 42, 31, 23, 42, 27, 48, 31, 35, 25, 52, 58, 62, 6, 80, 29, 72, 54, 43, 48, 29, 50, 49, 19, 53, 48, 36, 35, 35, 9, 55, 37, 20, 56, 46, 50, 13, 48, 13, 18, 41, 52, 35, 33, 43, 39, 25, 31, 41, 32, 55, 28, 41, 43, 15, 66, 16, 47, 18, 40, 25, 27, 45, 39, 30, 43, 52, 44, 24, 74, 45, 36, 28, 46, 43, 7, 27, 48, 44, 80, 39, 46, 39, 31, 34, 29, 19, 8, 36, 37, 12, 43, 54, 20, 22, 31, 28, 45, 19, 40, 47, 44, 54, 32, 20, 39, 51, 61, 42, 33, 72, 38, 30, 48, 28, 36, 32, 31, 59, 38, 37, 67, 68, 14, 20, 33, 59, 44, 35, 18, 49, 53, 63, 27, 45, 41, 38, 35, 42, 13, 34, 23, 26, 64, 21, 24, 55, 42, 52, 35, 26, 24, 33, 29, 51, 50, 21, 42, 58, 48, 25, 34, 46, 21, 44, 29, 42, 43, 55, 48, 38, 54, 27, 38, 29, 29, 40, 51, 20, 66, 29, 39, 41, 23, 54, 27, 37, 44, 29, 40, 52, 18, 35, 25, 31, 41, 22, 28, 22, 55, 55, 27, 17, 69, 75, 33, 32, 65, 34, 60, 40, 39, 36, 21, 36, 59, 10, 44, 16, 41, 25, 11, 30, 33, 40, 63, 27, 38, 56, 49, 49, 33, 30, 26, 61, 28, 26, 48, 37, 42, 46, 25, 50, 21, 33, 78, 26, 19, 36, 34, 40, 33, 42, 50, 35, 33, 52, 46, 46, 28, 23, 55, 26, 30, 31, 42, 40, 63, 63, 43, 32, 42, 32, 13, 37, 53, 42, 22, 51, 61, 18, 25, 20, 36, 20, 36, 19, 41, 30, 64, 57, 38, 35, 31, 40, 46, 45, 31, 42, 24, 37, 33, 28, 53, 9, 35, 20, 30, 9, 49, 30, 52, 51, 61, 41, 11, 29, 37, 50, 49, 32, 50, 72, 49, 58, 32, 45, 30, 19, 30, 52, 16, 41, 38, 41, 41, 33, 22, 31, 44, 57, 24, 67, 52, 29, 29, 10, 56, 60, 76, 33, 69, 26, 32, 62, 18, 20, 38, 16, 50, 30, 31, 36, 40, 46, 26, 75, 34, 46, 34, 61, 28, 65, 37, 30, 62, 65, 35, 50, 27, 51, 43, 34, 32, 22, 41, 30, 35, 30, 60, 44, 50, 46, 26, 27, 39, 62, 23, 25, 36, 41, 50, 35, 36, 21, 28, 18, 58, 22, 11, 27, 26, 41, 36, 30, 60, 37, 64, 29, 56, 21, 44, 33, 49, 49, 53, 38, 41, 24, 60, 38, 26, 60, 9, 54, 42, 23, 46, 77, 23, 42, 37, 30, 23, 15, 26, 35, 21, 25, 39, 45, 28, 58, 52, 26, 34, 55, 59, 11, 21, 7, 57, 17, 28, 41, 54, 29, 38, 39, 29, 19, 39, 45, 52, 54, 40, 38, 22, 42, 46, 35, 29, 20, 35, 21, 42, 40, 32, 50, 27, 48, 68, 25, 44, 42, 64, 35, 77, 15, 32, 32, 31, 45, 52, 14, 63, 48, 17, 45, 37, 16, 21, 13, 39, 26, 29, 49, 24, 41, 39, 43, 41, 35, 34, 21, 39, 37, 23, 28, 51, 51, 27, 33, 36, 40, 49, 39, 40, 50, 41, 62, 49, 59, 39, 48, 49, 16, 39, 51, 47, 32, 51, 27, 36, 39, 28, 50, 27, 28, 18, 36, 37, 28, 23, 27, 15, 60, 49, 29, 13, 24, 32, 36, 51, 23, 27, 70, 13, 28, 57, 19, 61, 27, 60, 23, 46, 39, 43, 22, 69, 42, 30, 39, 9, 17, 53, 27, 45, 52, 29, 7, 13, 45, 45, 47, 36, 65, 49, 59, 41, 33, 26, 65, 21, 23, 19, 48, 27, 56, 38, 57, 47, 42, 63, 45, 33, 15, 22, 14, 15, 30, 51, 38, 39, 41, 48, 31, 39, 61, 29, 75, 47, 35, 58, 50, 26, 40, 53, 65, 53, 43, 44, 56, 45, 60, 40, 22, 33, 59, 53, 47, 56, 67, 47, 46, 45, 34, 75, 48, 29, 62, 24, 34, 36, 55, 31, 67, 17, 36, 29, 51, 41, 33, 25, 48, 38, 16, 63, 46, 43, 46, 45, 35, 45, 77, 35, 28, 66, 51, 20, 41, 36, 23, 65, 40, 37, 30, 51, 23, 38, 15, 63, 47, 37, 24, 18, 28, 42, 27, 44, 36, 46, 43, 41, 46, 57, 49, 43, 40, 44, 53, 23, 33, 63, 30, 32, 36, 47, 43, 35, 7, 67, 48, 33, 54, 12, 64, 57, 12, 52, 8, 58, 45, 42, 43, 54, 54, 59, 32, 35, 36, 20, 43, 40, 37, 45, 38, 41, 50, 29, 15, 34, 73, 30, 37, 55, 47, 21, 33, 37, 39, 60, 14, 52, 67, 48, 12, 37, 40, 57, 59, 64, 47, 13, 31, 57, 59, 30, 30, 22, 39, 38, 13, 32, 46, 24, 47, 16, 44, 32, 49, 28, 61, 65, 24, 24, 19, 22, 42, 20, 51, 43, 25, 27, 54, 28, 55, 36, 27, 32, 27, 55, 51, 41, 46, 37, 53, 19, 68, 44, 65, 29, 22, 55, 14, 59, 76, 50, 37, 46, 49, 38, 20, 34, 58, 52, 62, 30, 48, 45, 37, 17, 51, 33, 41, 18, 34, 17, 22, 51, 48, 14, 69, 26, 47, 54, 31, 19, 49, 49, 53, 51, 50, 69, 53, 27, 24, 33, 48, 50, 37, 42, 48, 37, 49, 68, 34, 49, 22, 44, 26, 39, 32, 43, 32, 55, 46, 73, 42, 18, 57, 53, 27, 3, 46, 51, 49, 59, 57, 26, 34, 32, 22, 47, 60, 35, 42, 28, 71, 30, 35, 52, 54, 54, 35, 35, 34, 37, 42, 70, 42, 33, 35, 56, 24, 34, 52, 54, 53, 41, 45, 24, 16, 35, 65, 38, 35, 45, 18, 46, 16, 19, 25, 34, 30, 49, 54, 28, 32, 46, 42, 30, 32, 31, 38, 28, 43, 34, 51, 52, 58, 45, 31, 59, 24, 31, 52, 33, 53, 26, 48, 45, 61, 38, 57, 36, 28, 37, 41, 40, 47, 25, 54, 17, 50, 30, 56, 26, 42, 34, 23, 19, 70, 45, 47, 68, 39, 24, 35, 56, 39, 26, 25, 22, 49, 40, 38, 32, 31, 32, 56, 48, 45, 43, 40, 58, 44, 37, 54, 40, 19, 27, 12, 41, 34, 29, 17, 86, 50, 49, 38, 22, 72, 33, 19, 47, 47, 59, 64, 62, 65, 62, 29, 49, 43, 46, 30, 70, 59, 40, 34, 52, 47, 29, 42, 31, 28, 68, 52, 24, 32, 40, 18, 35, 28, 41, 31, 58, 29, 58, 36, 31, 32, 34, 48, 66, 32, 34, 48, 35, 31, 22, 38, 23, 21, 42, 41, 34, 24, 65, 55, 29, 47, 43, 56, 38, 18, 31, 32, 54, 18, 22, 43, 67, 55, 24, 39, 49, 35, 46, 28, 28, 49, 18, 52, 28, 74, 62, 60, 59, 23, 36, 28, 61, 58, 68, 16, 25, 41, 38, 21, 51, 28, 56, 43, 38, 24, 29, 65, 37, 44, 25, 41, 40, 36, 36, 38, 57, 63, 29, 41, 51, 16, 71, 59, 14, 19, 36, 20, 31, 59, 75, 24, 36, 52, 53, 29, 50, 51, 68, 24, 49, 49, 18, 63, 57, 46, 46, 34, 63, 38, 40, 39, 46, 45, 49, 3, 73, 23, 30, 43, 63, 45, 46, 33, 20, 65, 35, 65, 65, 44, 19, 38, 14, 41, 53, 54, 61, 55, 40, 28, 53, 38, 38, 49, 65, 61, 50, 31, 42, 48, 13, 26, 64, 71, 46, 29, 25, 28, 60, 62, 48, 37, 73, 43, 21, 32, 57, 48, 20, 43, 52, 45, 47, 67, 21, 29, 32, 16, 56, 32, 71, 35, 29, 38, 52, 37, 57, 52, 19, 39, 65, 26, 33, 36, 25, 47, 40, 44, 36, 55, 28, 25, 25, 27, 44, 42, 36, 64, 24, 30, 41, 24, 30, 54, 38, 35, 43, 27, 57, 51, 34, 20, 15, 45, 34, 34, 49, 14, 28, 61, 50, 53, 69, 33, 9, 29, 55, 54, 45, 27, 51, 29, 68, 52, 52, 59, 18, 28, 21, 35, 52, 13, 19, 34, 40, 41, 33, 43, 38, 54, 66, 77, 11, 31, 51, 59, 34, 25, 66, 44, 25, 41, 21, 52, 36, 40, 26, 32, 31, 42, 52, 41, 27, 41, 25, 27, 45, 38, 48, 45, 27, 44, 31, 19, 38, 21, 57, 38, 65, 36, 57, 37, 38, 73, 48, 51, 52, 54, 37, 55, 52, 20, 37, 38, 48, 16, 45, 20, 36, 43, 51, 12, 27, 60, 46, 63, 48, 67, 31, 42, 37, 64, 21, 30, 49, 47, 41, 29, 45, 52, 35, 32, 61, 13, 36, 44, 35, 34, 40, 26, 38, 46, 48, 60, 52, 19, 29, 35, 37, 22, 61, 23, 43, 28, 27, 63, 30, 34, 52, 35, 56, 50, 37, 31, 16, 51, 39, 53, 52, 16, 24, 57, 23, 29, 26, 39, 40, 51, 53, 38, 54, 47, 35, 44, 44, 51, 29, 43, 55, 61, 39, 33, 43, 42, 51, 11, 47, 29, 67, 25, 47, 10, 66, 61, 29, 61, 20, 18, 51, 50, 36, 22, 42, 44, 43, 55, 21, 23, 28, 68, 24, 31, 70, 73, 70, 43, 16, 49, 32, 19, 56, 73, 28, 32, 39, 15, 46, 18, 42, 20, 43, 15, 65, 66, 21, 59, 27, 44, 31, 31, 38, 72, 44, 32, 46, 41, 40, 58, 33, 53, 63, 22, 16, 38, 40, 24, 61, 19, 29, 11, 18, 23, 49, 22, 20, 60, 35, 53, 28, 59, 49, 56, 27, 35, 61, 47, 61, 50, 44, 40, 22, 29, 59, 61, 59, 21, 52, 32, 44, 36, 23, 55, 42, 12, 55, 33, 46, 49, 10, 56, 25, 29, 42, 53, 55, 50, 27, 18, 22, 50, 47, 41, 54, 20, 56, 62, 18, 40, 26, 6, 62, 41, 51, 33, 36, 53, 52, 60, 17, 48, 36, 30, 27, 41, 27, 57, 14, 41, 53, 36, 44, 52, 27, 20, 44, 71, 38, 18, 35, 39, 34, 42, 17, 58, 47, 22, 28, 48, 19, 37, 38, 39, 12, 29, 61, 19, 30, 18, 31, 41, 53, 35, 32, 52, 20, 55, 35, 41, 45, 45, 35, 35, 50, 37, 29, 28, 53, 26, 55, 51, 31, 44, 25, 29, 21, 45, 42, 35, 17, 51, 34, 47, 70, 51, 48, 11, 44, 15, 64, 40, 51, 25, 47, 48, 53, 49, 47, 47, 42, 52, 50, 42, 52, 39, 48, 35, 51, 53, 34, 49, 59, 47, 45, 58, 27, 26, 22, 37, 42, 66, 46, 29, 52, 54, 34, 52, 39, 33, 52, 43, 41, 35, 46, 37, 47, 28, 40, 11, 37, 51, 55, 28, 71, 54, 48, 18, 45, 52, 41, 25, 19, 24, 54, 45, 36, 31, 31, 10, 45, 36, 41, 44, 41, 30, 65, 57, 65, 68, 24, 34, 50, 40, 56, 36, 26, 33, 71, 45, 5, 21, 50, 52, 31, 22, 30, 35, 56, 18, 28, 15, 37, 28, 37, 60, 36, 25, 26, 55, 54, 44, 55, 49, 49, 16, 42, 19, 39, 42, 46, 46, 41, 30, 28, 42, 69, 52, 32, 61, 45, 38, 9, 24, 28, 13, 26, 54, 49, 37, 47, 38, 49, 22, 55, 53, 48, 19, 46, 33, 27, 61, 31, 47, 46, 25, 25, 54, 18, 52, 38, 36, 27, 11, 42, 44, 48, 71, 42, 22, 53, 67, 26, 32, 49, 40, 32, 16, 36, 52, 27, 39, 44, 62, 85, 51, 41, 55, 64, 50, 39, 27, 38, 40, 35, 61, 24, 14, 55, 48, 49, 50, 44, 14, 17, 42, 59, 30, 38, 23, 55, 29, 34, 34, 44, 55, 28, 9, 27, 49, 49, 12, 51, 38, 44, 46, 55, 26, 42, 38, 18, 53, 70, 28, 70, 58, 41, 42, 44, 31, 46, 43, 22, 59, 22, 17, 18, 24, 32, 31, 51, 26, 14, 65, 47, 47, 55, 55, 29, 27, 55, 36, 38, 52, 36, 31, 44, 29, 29, 36, 39, 34, 22, 32, 44, 45, 22, 37, 16, 65, 46, 41, 18, 52, 48, 36, 36, 8, 60, 64, 29, 61, 35, 41, 46, 29, 34, 71, 26, 49, 42, 46, 60, 56, 35, 11, 58, 27, 42, 55, 47, 39, 28, 36, 34, 59, 38, 50, 58, 34, 59, 31, 41, 39, 14, 42, 27, 33, 34, 45, 56, 63, 46, 40, 21, 45, 34, 33, 44, 49, 35, 25, 35, 19, 62, 42, 34, 49, 63, 43, 48, 59, 55, 37, 26, 16, 82, 61, 41, 19, 11, 32, 50, 47, 55, 27, 26, 21, 28, 40, 69, 42, 45, 74, 40, 19, 38, 21, 62, 39, 31, 59, 29, 59, 27, 27, 56, 37, 35, 28, 26, 59, 39, 74, 59, 31, 56, 67, 48, 31, 28, 72, 27, 29, 36, 26, 44, 32, 39, 39, 74, 61, 34, 47, 47, 55, 21, 32, 18, 55, 24, 33, 46, 37, 56, 29, 39, 55, 41, 34, 36, 31, 48, 31, 49, 31, 63, 10, 87, 42, 38, 28, 32, 46, 29, 34, 52, 59, 21, 17, 31, 30, 57, 37, 37, 26, 46, 29, 58, 63, 18, 66, 37, 55, 53, 43, 53, 21, 47, 31, 41, 38, 26, 49, 36, 53, 37, 45, 63, 48, 13, 48, 39, 26, 35, 45, 43, 27, 49, 39, 29, 16, 49, 26, 26, 44, 45, 21, 39, 41, 52, 15, 25, 53, 36, 58, 45, 50, 32, 47, 40, 47, 38, 54, 55, 58, 48, 43, 50, 60, 43, 48, 20, 13, 32, 44, 57, 39, 12, 44, 59, 58, 33, 43, 59, 65, 58, 41, 25, 51, 33, 54, 32, 32, 34, 41, 65, 41, 48, 34, 38, 14, 54, 40, 46, 73, 18, 33, 37, 30, 42, 39, 29, 71, 29, 21, 38, 17, 45, 49, 25, 52, 35, 34, 42, 14, 40, 19, 40, 35, 45, 28, 36, 32, 64, 43, 50, 33, 27, 60, 42, 36, 36, 49, 69, 61, 41, 60, 27, 55, 25, 42, 43, 22, 39, 57, 48, 35, 53, 52, 47, 41, 27, 58, 43, 59, 27, 48, 20, 31, 52, 26, 50, 23, 75, 49, 37, 45, 57, 56, 44, 39, 34, 45, 30, 18, 35, 30, 76, 28, 51, 40, 55, 61, 67, 53, 24, 42, 42, 36, 51, 53, 71, 39, 31, 30, 42, 35, 24, 41, 65, 51, 16, 43, 47, 41, 50, 41, 24, 60, 24, 32, 48, 24, 64, 31, 60, 43, 18, 44, 41, 17, 38, 12, 34, 42, 38, 48, 7, 13, 62, 63, 13, 41, 51, 31, 34, 29, 35, 48, 38, 15, 53, 32, 70, 40, 8, 31, 22, 27, 26, 54, 16, 43, 15, 22, 42, 48, 53, 64, 63, 20, 37, 40, 36, 4, 42, 42, 43, 32, 54, 66, 72, 30, 38, 30, 35, 41, 47, 21, 18, 63, 33, 31, 39, 59, 42, 20, 47, 27, 47, 59, 22, 34, 45, 14, 63, 40, 54, 25, 19, 44, 46, 60, 55, 47, 48, 16, 34, 37, 49, 22, 34, 17, 17, 59, 25, 44, 39, 47, 31, 40, 38, 50, 50, 50, 46, 45, 38, 39, 23, 12, 21, 47, 15, 37, 38, 20, 27, 58, 37, 70, 28, 18, 41, 12, 29, 30, 47, 27, 50, 29, 39, 17, 31, 17, 41, 29, 50, 42, 65, 32, 13, 17, 34, 54, 32, 48, 39, 67, 56, 15, 41, 36, 39, 28, 30, 45, 45, 34, 46, 30, 40, 56, 48, 26, 43, 22, 61, 31, 28, 29, 50, 16, 65, 54, 44, 52, 28, 32, 19, 42, 42, 39, 39, 59, 28, 60, 66, 23, 31, 24, 28, 13, 60, 38, 27, 35, 48, 59, 40, 62, 46, 70, 25, 54, 50, 32, 46, 57, 40, 38, 11, 45, 53, 21, 50, 30, 40, 43, 16, 32, 51, 42, 49, 60, 60, 37, 44, 73, 45, 55, 33, 42, 31, 49, 44, 21, 62, 50, 58, 26, 17, 71, 17, 27, 39, 50, 40, 43, 44, 31, 21, 44, 43, 22, 60, 29, 57, 20, 39, 44, 33, 34, 34, 41, 16, 25, 51, 23, 48, 17, 34, 24, 40, 27, 39, 28, 24, 26, 36, 37, 23, 57, 29, 56, 23, 41, 67, 35, 23, 10, 69, 56, 53, 50, 45, 32, 52, 39, 42, 30, 36, 47, 47, 36, 21, 21, 51, 24, 72, 10, 17, 52, 39, 39, 19, 20, 36, 54, 36, 34, 49, 63, 37, 24, 21, 43, 28, 65, 32, 29, 38, 23, 31, 9, 44, 51, 26, 52, 54, 28, 52, 46, 32, 50, 43, 46, 40, 24, 42, 38, 24, 46, 44, 40, 29, 35, 27, 55, 32, 28, 23, 13, 33, 31, 37, 18, 19, 37, 42, 18, 24, 36, 25, 54, 65, 6, 43, 27, 37, 68, 42, 33, 41, 48, 45, 66, 15, 27, 34]}, 'test_4': {'capacity': 100, 'num_items': 5000, 'items': [38, 34, 46, 40, 59, 55, 27, 37, 11, 63, 9, 31, 18, 52, 43, 50, 47, 34, 44, 47, 50, 41, 17, 40, 52, 55, 27, 29, 28, 54, 13, 57, 40, 15, 35, 27, 13, 28, 20, 8, 24, 47, 38, 48, 26, 34, 36, 47, 39, 10, 19, 57, 39, 44, 43, 56, 31, 48, 50, 26, 52, 52, 56, 41, 49, 37, 46, 37, 29, 47, 43, 30, 32, 24, 47, 37, 55, 47, 43, 10, 50, 27, 50, 27, 33, 51, 15, 43, 45, 48, 44, 59, 32, 44, 40, 46, 66, 39, 51, 30, 38, 25, 38, 28, 48, 50, 14, 41, 39, 31, 33, 38, 17, 24, 32, 23, 18, 55, 41, 40, 66, 35, 51, 63, 50, 88, 31, 63, 34, 51, 58, 32, 43, 59, 65, 43, 40, 31, 47, 66, 47, 45, 61, 24, 43, 53, 37, 36, 57, 19, 51, 6, 29, 41, 30, 11, 25, 50, 53, 53, 52, 42, 22, 29, 39, 25, 25, 34, 52, 50, 42, 59, 42, 50, 52, 49, 22, 60, 37, 50, 45, 24, 30, 40, 64, 33, 64, 47, 26, 55, 29, 39, 60, 27, 34, 41, 43, 35, 49, 40, 39, 51, 33, 45, 48, 64, 19, 47, 23, 41, 53, 35, 43, 33, 39, 34, 63, 27, 42, 34, 54, 52, 74, 27, 59, 71, 56, 33, 41, 16, 74, 34, 38, 41, 29, 30, 28, 28, 51, 29, 53, 27, 6, 15, 35, 63, 16, 52, 43, 21, 41, 21, 36, 32, 52, 39, 32, 25, 37, 52, 58, 21, 32, 35, 61, 52, 23, 58, 36, 19, 51, 61, 42, 40, 30, 34, 25, 28, 28, 19, 20, 30, 34, 63, 30, 53, 49, 24, 20, 54, 45, 18, 52, 49, 43, 37, 33, 44, 42, 43, 50, 33, 25, 29, 64, 43, 63, 45, 58, 59, 50, 73, 48, 34, 8, 26, 50, 21, 80, 24, 36, 26, 37, 65, 53, 50, 50, 60, 33, 81, 43, 57, 25, 67, 35, 35, 47, 52, 14, 60, 36, 27, 52, 24, 37, 44, 57, 42, 33, 37, 39, 43, 58, 44, 35, 46, 50, 47, 74, 25, 46, 27, 53, 54, 37, 46, 39, 27, 32, 49, 77, 37, 68, 34, 63, 56, 44, 45, 26, 74, 47, 52, 37, 37, 67, 26, 28, 39, 49, 25, 34, 40, 30, 56, 47, 50, 56, 32, 26, 50, 51, 40, 27, 61, 54, 42, 25, 43, 17, 41, 49, 26, 51, 22, 15, 52, 50, 31, 28, 31, 55, 32, 20, 33, 54, 49, 32, 42, 68, 47, 64, 6, 37, 38, 44, 37, 25, 9, 60, 44, 38, 40, 62, 48, 49, 55, 40, 55, 41, 40, 42, 51, 46, 61, 54, 45, 34, 48, 80, 63, 28, 31, 41, 49, 30, 41, 13, 48, 65, 59, 33, 42, 24, 48, 48, 30, 75, 43, 62, 60, 65, 15, 19, 33, 47, 36, 21, 31, 41, 23, 38, 51, 42, 58, 14, 42, 12, 20, 37, 35, 42, 43, 15, 43, 28, 42, 34, 55, 35, 43, 49, 28, 16, 40, 26, 27, 41, 35, 27, 46, 38, 31, 36, 21, 35, 64, 35, 33, 42, 13, 49, 51, 59, 53, 18, 27, 67, 20, 38, 26, 37, 33, 44, 31, 21, 23, 46, 38, 36, 65, 39, 52, 35, 42, 30, 38, 33, 45, 72, 21, 35, 54, 29, 57, 52, 33, 20, 30, 45, 33, 53, 73, 48, 49, 32, 36, 62, 66, 30, 56, 53, 29, 42, 24, 46, 39, 20, 43, 38, 52, 25, 58, 22, 38, 44, 48, 34, 40, 32, 8, 35, 45, 25, 68, 30, 45, 67, 56, 40, 22, 30, 74, 27, 48, 33, 67, 39, 11, 37, 53, 45, 57, 42, 45, 50, 47, 40, 40, 61, 64, 51, 28, 18, 12, 49, 43, 47, 44, 55, 31, 53, 37, 31, 47, 48, 31, 39, 42, 50, 14, 33, 42, 39, 50, 37, 55, 47, 50, 78, 37, 38, 30, 61, 39, 48, 30, 26, 48, 62, 46, 27, 54, 38, 36, 46, 34, 35, 64, 24, 39, 75, 29, 70, 38, 28, 39, 10, 24, 49, 47, 33, 47, 58, 30, 10, 26, 28, 43, 33, 29, 46, 36, 35, 19, 36, 10, 37, 31, 7, 42, 46, 63, 82, 49, 42, 42, 22, 54, 42, 50, 30, 51, 61, 48, 43, 29, 13, 33, 36, 58, 38, 47, 59, 57, 19, 33, 56, 7, 49, 41, 49, 11, 40, 68, 28, 11, 36, 39, 26, 26, 64, 25, 36, 18, 53, 33, 39, 45, 62, 30, 23, 38, 31, 26, 35, 26, 4, 44, 39, 34, 29, 23, 36, 62, 39, 41, 38, 14, 55, 19, 46, 57, 51, 37, 19, 27, 33, 36, 34, 38, 43, 27, 66, 30, 27, 46, 48, 48, 59, 81, 58, 40, 50, 35, 45, 51, 53, 53, 46, 52, 39, 17, 49, 35, 32, 41, 54, 46, 33, 42, 44, 24, 43, 45, 28, 29, 44, 44, 34, 46, 44, 17, 54, 27, 39, 42, 41, 26, 39, 57, 38, 17, 21, 52, 47, 24, 32, 37, 45, 13, 62, 48, 31, 42, 19, 23, 30, 50, 15, 31, 28, 42, 51, 45, 47, 23, 40, 52, 85, 54, 36, 20, 38, 34, 18, 25, 14, 34, 43, 21, 35, 39, 45, 33, 52, 24, 40, 51, 29, 26, 51, 41, 64, 57, 29, 45, 48, 35, 37, 38, 42, 46, 36, 43, 26, 41, 62, 62, 63, 6, 21, 30, 30, 21, 36, 33, 58, 41, 53, 29, 42, 9, 57, 27, 37, 48, 25, 23, 31, 33, 32, 42, 35, 15, 13, 61, 30, 16, 47, 25, 31, 62, 5, 50, 19, 38, 61, 27, 26, 35, 40, 24, 31, 30, 18, 18, 41, 36, 61, 11, 46, 7, 8, 42, 39, 28, 28, 33, 37, 37, 44, 6, 53, 35, 29, 35, 67, 29, 31, 49, 34, 46, 21, 23, 35, 48, 28, 38, 67, 45, 59, 44, 50, 61, 24, 49, 58, 9, 16, 40, 14, 18, 34, 47, 37, 56, 22, 41, 39, 35, 59, 57, 34, 24, 16, 48, 36, 38, 44, 23, 79, 24, 10, 36, 51, 32, 39, 43, 55, 28, 27, 25, 42, 45, 63, 24, 41, 47, 19, 32, 26, 57, 30, 24, 32, 62, 73, 35, 65, 30, 67, 38, 41, 30, 37, 48, 22, 58, 50, 8, 42, 44, 72, 42, 67, 24, 64, 55, 54, 42, 13, 13, 27, 27, 19, 53, 28, 33, 23, 36, 70, 54, 55, 37, 56, 35, 35, 53, 3, 43, 26, 43, 29, 69, 45, 61, 45, 46, 19, 40, 25, 43, 38, 62, 45, 58, 71, 45, 28, 42, 42, 11, 56, 58, 39, 35, 66, 23, 30, 42, 35, 50, 24, 44, 61, 56, 42, 41, 56, 48, 54, 21, 35, 51, 21, 29, 16, 44, 40, 50, 34, 38, 63, 58, 20, 51, 30, 39, 33, 29, 7, 39, 36, 59, 16, 45, 54, 49, 73, 30, 55, 32, 53, 83, 28, 44, 38, 54, 32, 23, 30, 50, 12, 52, 52, 46, 28, 47, 32, 26, 8, 60, 9, 36, 27, 27, 69, 49, 45, 31, 16, 48, 14, 31, 36, 44, 35, 48, 47, 51, 55, 40, 43, 42, 21, 51, 70, 53, 18, 37, 37, 53, 26, 28, 53, 65, 33, 27, 17, 42, 32, 19, 65, 31, 13, 32, 42, 24, 45, 54, 51, 48, 45, 54, 60, 31, 62, 43, 43, 43, 58, 33, 9, 46, 43, 16, 77, 52, 55, 46, 70, 78, 35, 42, 27, 24, 62, 40, 41, 43, 60, 43, 46, 27, 54, 47, 49, 51, 35, 42, 46, 21, 37, 47, 13, 39, 42, 21, 24, 45, 11, 50, 29, 36, 43, 49, 46, 28, 36, 47, 49, 42, 35, 57, 44, 41, 51, 59, 68, 37, 40, 32, 67, 21, 35, 28, 36, 35, 60, 39, 35, 39, 13, 51, 24, 8, 21, 59, 34, 42, 33, 41, 44, 22, 35, 33, 45, 80, 36, 42, 26, 25, 45, 46, 23, 30, 27, 53, 58, 50, 71, 39, 35, 49, 18, 56, 43, 16, 51, 24, 60, 53, 57, 51, 27, 34, 49, 47, 55, 37, 13, 11, 34, 53, 21, 24, 29, 61, 56, 45, 15, 33, 40, 31, 18, 36, 44, 9, 20, 41, 48, 34, 38, 35, 65, 48, 18, 11, 37, 28, 39, 51, 59, 42, 54, 44, 41, 10, 30, 54, 44, 38, 22, 44, 11, 54, 30, 40, 50, 49, 34, 26, 33, 39, 31, 44, 51, 47, 40, 41, 9, 42, 28, 45, 28, 36, 47, 50, 7, 47, 64, 43, 44, 46, 46, 11, 45, 26, 29, 31, 61, 44, 53, 71, 31, 69, 6, 42, 38, 51, 34, 51, 38, 45, 27, 29, 32, 25, 32, 25, 36, 43, 56, 49, 36, 36, 60, 46, 24, 36, 45, 57, 56, 41, 43, 35, 18, 52, 33, 41, 66, 71, 25, 28, 17, 11, 40, 34, 34, 12, 38, 31, 24, 52, 39, 19, 66, 55, 24, 43, 24, 33, 39, 66, 30, 24, 8, 62, 55, 64, 40, 59, 53, 42, 52, 29, 26, 24, 40, 32, 43, 30, 38, 55, 39, 16, 27, 33, 58, 31, 66, 35, 30, 26, 18, 34, 50, 35, 23, 30, 36, 36, 21, 33, 46, 52, 48, 31, 30, 29, 9, 27, 26, 40, 39, 45, 38, 60, 40, 34, 49, 45, 78, 34, 29, 56, 38, 20, 83, 19, 34, 37, 33, 54, 69, 47, 32, 49, 45, 48, 42, 19, 44, 30, 21, 39, 30, 29, 67, 37, 29, 33, 74, 38, 36, 10, 26, 27, 26, 49, 57, 56, 26, 34, 33, 9, 20, 22, 36, 53, 16, 69, 28, 35, 58, 53, 9, 50, 43, 30, 58, 49, 39, 40, 27, 42, 40, 42, 19, 39, 46, 58, 62, 30, 48, 30, 39, 36, 17, 37, 51, 18, 56, 48, 18, 24, 39, 21, 48, 8, 45, 36, 42, 44, 38, 50, 40, 51, 27, 23, 47, 16, 62, 49, 37, 44, 50, 17, 45, 45, 68, 12, 22, 59, 54, 38, 11, 43, 51, 21, 34, 29, 49, 41, 17, 33, 78, 18, 30, 47, 71, 33, 56, 44, 55, 46, 48, 50, 45, 31, 45, 27, 50, 46, 36, 43, 40, 59, 52, 53, 44, 29, 33, 59, 29, 55, 48, 38, 38, 21, 52, 22, 35, 38, 19, 31, 51, 47, 52, 41, 29, 26, 28, 60, 27, 40, 61, 44, 39, 36, 34, 37, 37, 39, 48, 73, 26, 24, 34, 29, 32, 59, 40, 41, 31, 14, 63, 19, 38, 45, 40, 58, 27, 55, 66, 45, 31, 28, 51, 22, 31, 15, 16, 31, 29, 34, 55, 52, 33, 46, 43, 70, 44, 40, 33, 31, 28, 52, 22, 37, 61, 17, 15, 21, 42, 54, 35, 25, 63, 15, 38, 52, 49, 58, 39, 65, 32, 31, 52, 43, 46, 44, 51, 34, 43, 56, 60, 80, 10, 46, 18, 17, 25, 37, 33, 34, 61, 31, 44, 64, 22, 30, 22, 35, 57, 38, 37, 42, 56, 39, 54, 25, 57, 52, 58, 36, 27, 36, 43, 24, 50, 60, 36, 16, 26, 18, 62, 50, 19, 39, 15, 34, 27, 49, 33, 22, 49, 45, 33, 43, 39, 65, 20, 44, 58, 42, 24, 38, 36, 23, 37, 41, 35, 33, 10, 31, 58, 59, 24, 36, 39, 61, 27, 43, 34, 37, 37, 31, 55, 44, 28, 11, 48, 34, 56, 41, 67, 51, 35, 26, 40, 22, 31, 46, 36, 21, 29, 22, 37, 31, 30, 68, 37, 47, 37, 33, 31, 72, 48, 33, 40, 44, 47, 52, 20, 25, 61, 27, 33, 57, 61, 46, 17, 29, 15, 68, 31, 35, 24, 54, 42, 24, 9, 12, 48, 52, 43, 43, 42, 23, 57, 53, 75, 36, 59, 46, 40, 38, 37, 51, 52, 30, 62, 41, 41, 71, 57, 20, 40, 51, 26, 60, 46, 57, 12, 9, 47, 26, 30, 30, 51, 27, 20, 47, 64, 36, 32, 34, 68, 31, 34, 18, 42, 24, 25, 17, 20, 78, 61, 47, 61, 19, 42, 27, 28, 52, 35, 14, 37, 51, 44, 44, 57, 48, 49, 46, 23, 41, 39, 37, 45, 70, 38, 30, 16, 36, 45, 26, 53, 29, 39, 29, 59, 28, 42, 31, 60, 52, 18, 34, 38, 52, 32, 40, 60, 81, 58, 55, 19, 28, 62, 54, 52, 35, 13, 9, 26, 26, 70, 49, 25, 30, 33, 12, 54, 29, 32, 51, 30, 64, 54, 28, 39, 23, 31, 22, 38, 40, 54, 42, 75, 34, 15, 33, 63, 37, 32, 21, 34, 47, 47, 39, 39, 49, 33, 31, 49, 43, 45, 55, 62, 39, 17, 53, 47, 39, 42, 22, 47, 64, 29, 17, 34, 24, 34, 47, 4, 32, 54, 63, 52, 32, 31, 43, 38, 36, 34, 21, 46, 60, 35, 25, 40, 18, 36, 50, 34, 27, 73, 48, 31, 48, 37, 19, 24, 61, 20, 36, 60, 32, 25, 39, 40, 38, 52, 21, 7, 52, 79, 60, 58, 57, 50, 50, 27, 40, 45, 21, 36, 28, 23, 38, 41, 35, 42, 6, 26, 23, 36, 19, 59, 41, 28, 45, 45, 57, 33, 55, 63, 42, 19, 35, 47, 17, 44, 31, 11, 7, 15, 36, 66, 42, 19, 41, 40, 30, 49, 49, 55, 51, 48, 21, 51, 39, 32, 42, 38, 61, 44, 26, 12, 25, 28, 52, 14, 56, 23, 47, 36, 51, 25, 31, 43, 34, 58, 25, 30, 34, 24, 90, 49, 36, 20, 55, 49, 43, 22, 64, 76, 33, 57, 50, 28, 42, 40, 23, 56, 39, 27, 23, 40, 47, 38, 49, 52, 39, 39, 43, 17, 44, 28, 43, 49, 53, 70, 31, 48, 63, 29, 25, 31, 45, 29, 40, 43, 46, 17, 27, 60, 56, 53, 54, 66, 30, 44, 29, 46, 32, 22, 40, 28, 34, 37, 19, 51, 42, 26, 19, 28, 66, 36, 33, 62, 23, 70, 62, 54, 49, 44, 39, 59, 58, 60, 39, 75, 41, 59, 33, 63, 51, 53, 38, 28, 52, 80, 39, 50, 29, 63, 48, 54, 32, 19, 11, 55, 27, 39, 36, 33, 18, 39, 15, 38, 23, 35, 46, 34, 31, 25, 26, 55, 30, 32, 22, 56, 45, 39, 31, 21, 28, 68, 36, 35, 45, 17, 36, 47, 23, 37, 17, 42, 53, 37, 42, 53, 45, 23, 34, 30, 26, 42, 39, 31, 43, 62, 55, 40, 75, 37, 41, 40, 26, 35, 26, 65, 18, 41, 37, 31, 43, 60, 62, 44, 42, 74, 41, 51, 30, 40, 49, 52, 55, 36, 22, 41, 50, 19, 53, 11, 32, 24, 18, 34, 62, 47, 39, 35, 34, 32, 35, 23, 36, 28, 37, 48, 65, 46, 57, 7, 26, 69, 38, 58, 50, 47, 38, 21, 50, 35, 45, 40, 46, 36, 48, 58, 36, 30, 54, 38, 56, 24, 44, 35, 30, 33, 27, 81, 44, 80, 45, 49, 38, 19, 23, 30, 27, 40, 71, 35, 67, 18, 33, 73, 46, 33, 44, 51, 31, 52, 44, 57, 51, 26, 27, 67, 23, 14, 36, 34, 41, 40, 55, 23, 37, 18, 21, 26, 43, 33, 42, 53, 21, 35, 52, 51, 30, 48, 30, 37, 50, 46, 8, 43, 30, 54, 53, 35, 58, 38, 47, 35, 8, 52, 38, 37, 81, 29, 43, 55, 37, 25, 49, 41, 39, 32, 38, 46, 59, 18, 46, 46, 44, 14, 35, 50, 49, 16, 33, 44, 36, 42, 77, 33, 36, 51, 39, 18, 58, 10, 43, 58, 60, 55, 41, 25, 63, 20, 39, 69, 29, 30, 65, 59, 23, 50, 25, 33, 36, 31, 44, 23, 54, 8, 49, 14, 31, 39, 61, 58, 32, 59, 37, 32, 57, 26, 38, 64, 61, 45, 37, 39, 45, 36, 28, 41, 38, 28, 20, 37, 57, 30, 36, 53, 42, 58, 26, 45, 18, 74, 53, 48, 52, 23, 49, 20, 35, 8, 27, 38, 65, 28, 7, 48, 29, 48, 50, 37, 41, 56, 36, 43, 44, 30, 32, 21, 48, 40, 29, 52, 56, 37, 57, 34, 16, 54, 20, 56, 33, 16, 38, 25, 74, 20, 52, 25, 60, 50, 29, 44, 60, 35, 32, 41, 42, 26, 43, 25, 30, 36, 31, 23, 48, 14, 29, 32, 59, 41, 32, 27, 23, 34, 41, 30, 46, 66, 52, 66, 31, 39, 25, 78, 24, 47, 33, 54, 7, 34, 56, 28, 33, 31, 40, 31, 15, 62, 42, 47, 44, 43, 25, 35, 32, 45, 6, 45, 20, 65, 13, 29, 47, 49, 43, 37, 51, 38, 50, 52, 48, 40, 55, 49, 23, 42, 38, 18, 21, 45, 56, 37, 33, 28, 50, 46, 43, 34, 67, 27, 22, 33, 44, 37, 27, 50, 46, 37, 14, 49, 24, 53, 34, 26, 54, 27, 35, 46, 45, 78, 18, 41, 25, 29, 30, 17, 17, 7, 50, 21, 69, 49, 61, 15, 35, 33, 7, 27, 20, 32, 45, 40, 54, 18, 15, 54, 42, 50, 41, 69, 45, 48, 49, 59, 27, 26, 63, 66, 35, 32, 50, 18, 31, 51, 62, 57, 59, 19, 47, 51, 32, 44, 65, 26, 43, 60, 65, 33, 50, 22, 32, 34, 45, 59, 90, 68, 52, 38, 37, 25, 46, 49, 29, 15, 46, 26, 36, 37, 50, 35, 29, 23, 31, 19, 68, 37, 34, 33, 49, 65, 43, 41, 52, 35, 37, 30, 30, 37, 30, 41, 58, 22, 36, 66, 43, 50, 49, 29, 39, 42, 70, 20, 30, 62, 41, 29, 29, 45, 38, 59, 46, 5, 31, 52, 44, 51, 60, 45, 33, 50, 40, 39, 46, 45, 63, 32, 53, 53, 43, 31, 34, 69, 36, 61, 18, 28, 26, 38, 31, 19, 55, 42, 53, 39, 62, 29, 55, 59, 22, 53, 29, 46, 39, 26, 26, 61, 38, 26, 50, 59, 53, 52, 42, 24, 25, 54, 15, 48, 43, 37, 31, 51, 26, 59, 37, 66, 68, 39, 39, 47, 28, 45, 42, 57, 41, 66, 21, 25, 58, 29, 40, 28, 27, 78, 39, 44, 27, 67, 63, 35, 63, 22, 49, 26, 44, 36, 34, 34, 38, 42, 44, 43, 41, 52, 7, 20, 51, 38, 50, 58, 35, 36, 27, 35, 48, 34, 67, 20, 48, 31, 40, 14, 65, 45, 75, 35, 32, 24, 46, 44, 30, 20, 50, 17, 38, 58, 60, 24, 53, 51, 56, 44, 65, 18, 52, 32, 35, 56, 37, 42, 48, 54, 48, 18, 22, 42, 32, 40, 39, 40, 41, 57, 53, 36, 26, 34, 26, 61, 42, 54, 50, 46, 56, 34, 43, 33, 41, 35, 20, 16, 32, 54, 50, 54, 60, 70, 24, 35, 47, 30, 13, 31, 46, 41, 36, 44, 48, 32, 33, 33, 56, 51, 39, 30, 46, 41, 54, 39, 48, 46, 43, 26, 34, 27, 43, 25, 57, 61, 62, 19, 47, 23, 27, 36, 48, 47, 58, 60, 23, 36, 31, 32, 10, 44, 46, 33, 49, 31, 67, 24, 40, 52, 15, 40, 44, 28, 48, 37, 40, 39, 45, 34, 50, 47, 29, 44, 20, 54, 35, 30, 51, 35, 44, 34, 54, 48, 35, 51, 28, 52, 36, 18, 40, 55, 19, 62, 58, 31, 22, 19, 32, 59, 42, 30, 32, 51, 67, 20, 38, 33, 94, 37, 59, 69, 61, 33, 35, 40, 43, 33, 28, 38, 48, 52, 43, 21, 55, 64, 38, 57, 47, 34, 39, 35, 40, 67, 34, 35, 64, 25, 21, 31, 41, 44, 24, 49, 54, 32, 23, 64, 64, 32, 37, 55, 45, 38, 45, 34, 35, 36, 35, 41, 29, 34, 55, 34, 45, 18, 48, 38, 24, 35, 45, 49, 34, 57, 34, 51, 57, 21, 47, 53, 64, 40, 54, 58, 14, 51, 63, 29, 56, 41, 64, 25, 21, 40, 75, 13, 50, 34, 45, 50, 65, 32, 42, 19, 41, 33, 18, 26, 35, 50, 40, 22, 34, 44, 55, 56, 10, 31, 13, 39, 20, 47, 12, 44, 52, 41, 43, 52, 31, 49, 35, 37, 58, 20, 17, 14, 38, 59, 27, 56, 21, 36, 54, 35, 26, 17, 26, 50, 32, 58, 37, 60, 57, 52, 42, 15, 54, 21, 18, 40, 48, 29, 38, 42, 48, 21, 46, 41, 48, 19, 20, 36, 21, 36, 49, 53, 16, 53, 22, 25, 62, 45, 23, 28, 30, 63, 44, 23, 37, 28, 22, 65, 43, 60, 21, 8, 25, 28, 52, 58, 46, 59, 4, 47, 64, 23, 35, 31, 33, 50, 45, 45, 24, 46, 51, 52, 68, 47, 19, 48, 63, 30, 38, 25, 41, 40, 59, 40, 23, 41, 27, 71, 30, 31, 73, 72, 52, 49, 30, 58, 53, 32, 72, 44, 45, 52, 43, 66, 43, 48, 17, 41, 27, 72, 24, 20, 63, 42, 36, 13, 41, 67, 40, 41, 34, 30, 39, 23, 38, 26, 46, 19, 26, 65, 46, 20, 31, 32, 49, 60, 58, 41, 9, 18, 29, 54, 34, 47, 51, 28, 44, 52, 44, 22, 56, 30, 52, 14, 41, 71, 50, 27, 15, 44, 25, 43, 39, 38, 58, 39, 51, 49, 27, 50, 52, 31, 17, 44, 45, 15, 42, 34, 51, 53, 55, 18, 66, 61, 22, 22, 36, 27, 64, 13, 76, 65, 36, 22, 30, 42, 57, 34, 52, 17, 58, 71, 39, 75, 24, 44, 18, 37, 64, 45, 23, 16, 22, 49, 46, 33, 46, 39, 41, 35, 30, 37, 25, 24, 47, 65, 20, 43, 55, 71, 27, 21, 55, 55, 48, 46, 8, 46, 46, 34, 19, 54, 58, 52, 42, 28, 13, 66, 33, 43, 21, 51, 55, 41, 43, 44, 48, 17, 22, 41, 39, 44, 53, 20, 32, 39, 64, 27, 50, 44, 43, 51, 34, 24, 26, 61, 42, 17, 45, 37, 60, 30, 22, 23, 44, 43, 33, 55, 29, 32, 31, 31, 51, 65, 80, 43, 57, 44, 29, 24, 12, 64, 42, 52, 24, 51, 22, 39, 42, 55, 33, 48, 47, 62, 31, 46, 14, 25, 55, 34, 21, 29, 47, 44, 21, 44, 58, 59, 24, 29, 38, 51, 39, 25, 44, 37, 62, 13, 48, 48, 39, 43, 12, 6, 52, 27, 47, 44, 34, 54, 42, 49, 38, 34, 35, 62, 35, 36, 49, 32, 19, 48, 61, 32, 57, 58, 27, 52, 44, 39, 26, 23, 42, 45, 56, 55, 52, 35, 38, 31, 31, 28, 20, 40, 48, 44, 40, 71, 63, 48, 44, 52, 47, 35, 63, 62, 25, 37, 35, 35, 39, 32, 43, 45, 58, 68, 25, 37, 50, 48, 30, 51, 31, 28, 52, 63, 50, 81, 36, 59, 48, 44, 27, 18, 19, 26, 54, 54, 39, 43, 24, 40, 13, 39, 22, 23, 29, 53, 34, 23, 61, 56, 43, 49, 48, 49, 42, 9, 27, 33, 39, 29, 26, 53, 46, 46, 43, 41, 28, 34, 29, 33, 43, 44, 15, 41, 30, 32, 55, 75, 50, 26, 55, 68, 15, 17, 22, 55, 33, 52, 23, 39, 39, 39, 74, 18, 21, 37, 36, 23, 64, 51, 20, 65, 38, 25, 68, 58, 33, 53, 27, 25, 59, 35, 49, 51, 28, 38, 40, 36, 27, 46, 24, 17, 47, 38, 64, 52, 18, 32, 20, 27, 48, 37, 46, 77, 10, 39, 33, 48, 29, 38, 37, 41, 81, 39, 19, 54, 46, 33, 60, 29, 52, 40, 14, 54, 38, 27, 34, 41, 37, 34, 57, 18, 23, 36, 31, 73, 39, 40, 33, 31, 22, 35, 36, 50, 28, 41, 31, 18, 38, 53, 27, 43, 33, 29, 34, 36, 48, 18, 39, 38, 27, 47, 51, 68, 44, 39, 16, 29, 54, 16, 42, 38, 43, 33, 25, 27, 56, 57, 57, 50, 59, 42, 46, 58, 48, 52, 37, 10, 25, 63, 18, 49, 26, 32, 23, 31, 47, 28, 11, 32, 54, 17, 66, 27, 31, 30, 50, 49, 36, 20, 32, 72, 30, 27, 14, 58, 40, 41, 51, 39, 48, 19, 49, 58, 58, 50, 54, 40, 29, 30, 33, 33, 44, 39, 39, 32, 37, 45, 38, 48, 28, 41, 40, 53, 52, 29, 38, 44, 57, 22, 39, 24, 45, 20, 38, 53, 43, 38, 54, 40, 35, 17, 53, 18, 34, 44, 18, 38, 55, 48, 46, 35, 26, 21, 34, 62, 53, 46, 30, 6, 18, 63, 56, 15, 58, 68, 47, 49, 47, 43, 26, 42, 31, 28, 42, 18, 35, 66, 45, 53, 67, 41, 31, 34, 48, 42, 57, 40, 47, 16, 67, 45, 61, 8, 12, 44, 74, 35, 41, 40, 37, 38, 46, 37, 56, 32, 57, 25, 51, 48, 47, 31, 60, 15, 64, 39, 46, 37, 38, 10, 48, 31, 62, 13, 26, 34, 33, 53, 61, 28, 67, 8, 33, 24, 32, 26, 66, 35, 52, 32, 43, 43, 27, 45, 34, 33, 35, 51, 33, 48, 39, 33, 40, 20, 30, 32, 34, 71, 62, 29, 54, 31, 24, 47, 11, 22, 18, 34, 41, 36, 65, 41, 35, 63, 27, 29, 44, 38, 13, 36, 23, 25, 40, 55, 47, 49, 46, 36, 53, 38, 16, 13, 28, 63, 28, 49, 15, 46, 12, 24, 50, 24, 49, 61, 79, 37, 21, 45, 33, 38, 38, 30, 49, 48, 52, 49, 45, 48, 9, 47, 49, 44, 49, 28, 28, 43, 10, 46, 52, 15, 51, 45, 54, 30, 10, 50, 25, 44, 25, 53, 50, 13, 65, 20, 66, 25, 39, 10, 40, 10, 38, 50, 36, 30, 51, 46, 53, 31, 41, 42, 35, 62, 51, 14, 33, 37, 57, 43, 56, 21, 22, 50, 41, 50, 27, 32, 11, 49, 56, 23, 54, 32, 46, 44, 29, 31, 25, 19, 50, 37, 46, 47, 48, 51, 20, 43, 57, 33, 44, 46, 70, 34, 45, 13, 36, 53, 28, 50, 10, 48, 27, 19, 52, 22, 51, 49, 65, 21, 40, 40, 18, 53, 27, 38, 37, 32, 74, 52, 23, 40, 54, 55, 51, 61, 34, 37, 43, 33, 33, 73, 48, 46, 48, 54, 49, 20, 33, 37, 43, 15, 36, 42, 40, 29, 43, 18, 31, 56, 36, 24, 57, 48, 67, 20, 16, 15, 62, 35, 53, 36, 43, 35, 35, 51, 62, 53, 66, 44, 34, 50, 34, 40, 58, 44, 52, 25, 30, 23, 52, 32, 50, 27, 28, 48, 30, 53, 50, 50, 35, 15, 22, 19, 45, 51, 22, 39, 36, 49, 61, 57, 58, 40, 43, 81, 79, 54, 41, 20, 22, 37, 12, 34, 61, 23, 37, 57, 36, 38, 43, 30, 60, 20, 45, 35, 32, 23, 27, 33, 30, 22, 24, 51, 23, 26, 35, 10, 70, 48, 38, 11, 24, 67, 32, 24, 62, 49, 24, 30, 49, 51, 31, 32, 14, 59, 50, 51, 30, 68, 38, 19, 37, 34, 46, 37, 63, 32, 21, 41, 43, 24, 41, 67, 26, 36, 46, 54, 61, 49, 35, 16, 16, 16, 56, 41, 41, 17, 40, 12, 46, 48, 19, 73, 31, 11, 52, 50, 26, 41, 55, 35, 23, 56, 22, 33, 60, 44, 23, 40, 23, 31, 43, 46, 26, 40, 40, 56, 29, 33, 24, 20, 53, 62, 22, 51, 68, 62, 56, 30, 56, 49, 64, 35, 39, 29, 36, 47, 24, 74, 36, 39, 54, 18, 21, 55, 34, 70, 24, 37, 31, 39, 63, 11, 42, 61, 31, 62, 46, 25, 38, 19, 53, 33, 26, 23, 52, 52, 36, 30, 10, 48, 58, 26, 29, 16, 23, 34, 22, 15, 26, 42, 15, 18, 46, 59, 58, 30, 42, 49, 16, 14, 50, 29, 27, 41, 48, 59, 42, 32, 33, 43, 43, 53, 52, 43, 63, 44, 19, 46, 43, 34, 50, 50, 23, 37, 36, 76, 50, 49, 54, 40, 35, 52, 42, 15, 32, 27, 22, 36, 26, 62, 31, 37, 50, 59, 35, 28, 18, 33, 39, 56, 44, 53, 39, 13, 12, 42, 44, 56, 58, 45, 31, 44, 74, 28, 46, 44, 31, 36, 40, 35, 41, 23, 34, 27, 27, 64, 39, 31, 51, 15, 38, 58, 41, 30, 31, 56, 44, 43, 41, 31, 10, 56, 66, 19, 54, 43, 35, 50, 40, 43, 50, 39, 19, 29, 17, 16, 46, 33, 11, 38, 47, 47, 33, 21, 45, 35, 37, 78, 69, 42, 59, 50, 30, 43, 50, 49, 29, 61, 46, 62, 25, 39, 67, 32, 43, 21, 26, 16, 26, 18, 55, 37, 33, 23, 33, 45, 47, 32, 51, 45, 23, 56, 49, 75, 28, 21, 34, 28, 40, 47, 34, 37, 43, 25, 31, 56, 65, 38, 14, 25, 33, 20, 7, 40, 39, 25, 56, 28, 51, 24, 52, 35, 46, 57, 52, 38, 56, 31, 18, 14, 20, 45, 36, 28, 24, 30, 50, 39, 43, 64, 31, 22, 48, 42, 42, 68, 51, 16, 37, 22, 43, 55, 22, 26, 41, 40, 29, 27, 35, 29, 59, 42, 50, 59, 31, 29, 52, 55, 30, 26, 30, 30, 39, 32, 40, 19, 45, 30, 32, 12, 52, 37, 26, 45, 36, 60, 58, 15, 9, 38, 38, 36, 44, 47, 27, 38, 46, 36, 44, 26, 28, 24, 32, 44, 14, 31, 62, 60, 61, 12, 45, 38, 55, 27, 30, 30, 70, 48, 38, 49, 33, 46, 47, 39, 43, 22, 29, 31, 37, 69, 14, 45, 81, 38, 45, 32, 13, 41, 7, 38, 44, 54, 45, 35, 13, 35, 53, 55, 25, 9, 15, 36, 40, 26, 35, 25, 45, 15, 55, 47, 22, 50, 29, 41, 35, 46, 25, 33, 23, 20, 35, 34, 31, 32, 29, 42, 46, 19, 60, 57, 31, 29, 31, 36, 50, 59, 51, 33, 31, 61, 64, 28, 58, 48, 43, 24, 33, 40, 43, 21, 48, 37, 44, 14, 31, 28, 41, 33, 50, 52, 59, 54, 50, 23, 47, 27, 28, 54, 44, 34, 28, 60, 46, 37, 29, 28, 54, 14, 26, 19, 41, 46, 31, 20, 74, 27, 31, 38, 48, 24, 48, 57, 72, 11, 43]}}\n\n\n \n #self.datasets = read_dataset_from_file('../weibull_instances/test_dataset_10k.pkl')\n # for test_num in range(5):\n # test_key = f'test_{test_num}'\n # data = np.array(self.datasets['Weibull 5k'][test_key]['items'])\n # print(data)\n # print(self.datasets['Weibull 5k'][test_key]['capacity'])\n # data = data / self.datasets['Weibull 5k'][test_key]['capacity']\n # self.datasets['Weibull 5k'][test_key]['capacity'] = 1.0\n # top_500_items = data[:1000]\n # self.datasets['Weibull 5k'][test_key]['items'] = top_500_items\n # self.datasets['Weibull 5k'][test_key]['num_items'] = 1000\n\n\n def read_dataset_from_file(self,filename):\n with open(filename, 'rb') as file:\n dataset = pickle.load(file)\n\n transformed_dataset = {}\n\n for num_items, instances in dataset.items():\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"] = {}\n for instance_num, items in enumerate(instances, 1):\n instance_name = f\"test_{instance_num-1}\"\n instance_data = {\n \"capacity\": 100,\n \"num_items\": num_items,\n \"items\": items\n }\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"][instance_name] = instance_data\n\n return transformed_dataset\n \n def l1_bound(self,items: tuple, capacity: int) -> float:\n \"\"\"Computes L1 lower bound on OPT for bin packing.\n\n Args:\n items: Tuple of items to pack into bins.\n capacity: Capacity of bins.\n\n Returns:\n Lower bound on number of bins required to pack items.\n \"\"\"\n return np.ceil(np.sum(items) / capacity)\n\n\n def l1_bound_dataset(self,instances: dict) -> float:\n \"\"\"Computes the mean L1 lower bound across a dataset of bin packing instances.\n\n Args:\n instances: Dictionary containing a set of bin packing instances.\n\n Returns:\n Average L1 lower bound on number of bins required to pack items.\n \"\"\"\n l1_bounds = []\n for name in instances:\n instance = instances[name]\n l1_bounds.append(self.l1_bound(instance['items'], instance['capacity']))\n return np.mean(l1_bounds)\n\n def get_instances(self,capacity,size):\n opt_num_bins = {}\n self.datasets = self.read_dataset_from_file('./testingdata/test_dataset_'+size+'.pkl')\n for test_num in range(len(self.datasets)):\n test_key = f'test_{test_num}'\n self.datasets['Weibull '+size][test_key]['capacity'] = capacity\n\n for name, dataset in self.datasets.items():\n opt_num_bins[name] = self.l1_bound_dataset(dataset)\n print(opt_num_bins)\n return self.datasets, opt_num_bins\n\n\n" }, { "path": "examples/bp_online_localLLM/evaluation/heuristic.py", "content": "# example heuristic\n# replace it with your own heuristic designed by EoH\n\ndef score(item, bins):\n scores = item - bins\n return scores" }, { "path": "examples/bp_online_localLLM/evaluation/results.txt", "content": "Weibull 1k, 100, Excess: 4.87%\nWeibull 5k, 100, Excess: 4.08%\nWeibull 10k, 100, Excess: 4.09%\nWeibull 1k, 300, Excess: 4.48%\nWeibull 5k, 300, Excess: 3.83%\nWeibull 10k, 300, Excess: 3.87%\nWeibull 1k, 500, Excess: 4.50%\nWeibull 5k, 500, Excess: 3.91%\nWeibull 10k, 500, Excess: 3.95%\n" }, { "path": "examples/bp_online_localLLM/evaluation/runEval.py", "content": "# -------\n# Evaluaiton code for EoH on Online Bin Packing\n#--------\n# More results may refer to \n# Fei Liu, Xialiang Tong, Mingxuan Yuan, Xi Lin, Fu Luo, Zhenkun Wang, Zhichao Lu, Qingfu Zhang \n# \"Evolution of Heuristics: Towards Efficient Automatic Algorithm Design Using Large Language Model\" \n# ICML 2024, https://arxiv.org/abs/2401.02051.\n\nimport importlib\nfrom get_instance import GetData\nfrom evaluation import Evaluation\n\neva = Evaluation()\n\ncapacity_list = [100,300,500]\n#size_list = ['1k','5k','10k','100k']\nsize_list = ['1k','5k','10k']\nwith open(\"results.txt\", \"w\") as file:\n for capacity in capacity_list:\n for size in size_list:\n getdate = GetData()\n instances, lb = getdate.get_instances(capacity, size) \n heuristic_module = importlib.import_module(\"heuristic\")\n heuristic = importlib.reload(heuristic_module) \n \n for name, dataset in instances.items():\n \n avg_num_bins = -eva.evaluateGreedy(dataset,heuristic)\n excess = (avg_num_bins - lb[name]) / lb[name]\n \n result = f'{name}, {capacity}, Excess: {100 * excess:.2f}%'\n print(result)\n file.write(result + \"\\n\")\n \n" }, { "path": "examples/bp_online_localLLM/evaluation/testingdata/generate_instances.py", "content": "import numpy as np\nimport pickle\n\ndef generate_weibull_dataset(num_instances, num_items, clipping_limit):\n dataset = {}\n\n for i in range(num_instances):\n items = []\n\n # Generate random samples from Weibull(45, 3) distribution\n samples = np.random.weibull(3, num_items) * 45\n\n # Clip the samples at the specified limit\n samples = np.clip(samples, 1, clipping_limit)\n\n # Round the item sizes to the nearest integer\n sizes = np.round(samples).astype(int)\n\n # Add the items to the instance\n for size in sizes:\n items.append(size)\n\n if num_items not in dataset:\n dataset[num_items] = []\n\n dataset[num_items].append(items)\n\n return dataset\n \ndef read_dataset_from_file(filename):\n with open(filename, 'rb') as file:\n dataset = pickle.load(file)\n\n transformed_dataset = {}\n\n for num_items, instances in dataset.items():\n transformed_dataset[f\"Weibull {num_items}k\"] = {}\n for instance_num, items in enumerate(instances, 1):\n instance_name = f\"test_{instance_num}\"\n instance_data = {\n \"capacity\": 100,\n \"num_items\": num_items,\n \"items\": items\n }\n transformed_dataset[f\"Weibull {num_items}k\"][instance_name] = instance_data\n\n return transformed_dataset\n\n# Generate training dataset with 5 instances and 5,000 items\ntraining_dataset = generate_weibull_dataset(5, 5000, 100)\n\n# Generate validation dataset with 5 instances and 5,000 items\nvalidation_dataset = generate_weibull_dataset(5, 5000, 100)\n\n# Generate test dataset with 5 instances and 5,000 items\ntest_dataset_05k = generate_weibull_dataset(5, 1000, 100)\n\n\n# Generate test dataset with 5 instances and 5,000 items\ntest_dataset_1k = generate_weibull_dataset(5, 2000, 100)\n\n# Generate test dataset with 5 instances and 5,000 items\ntest_dataset_5k = generate_weibull_dataset(5, 5000, 100)\n\n# Generate test dataset with 5 instances and 10,000 items\ntest_dataset_10k = generate_weibull_dataset(5, 10000, 100)\n\n# Generate test dataset with 1 instance and 100,000 items\ntest_dataset_100k = generate_weibull_dataset(1, 100000, 100)\n\n# Write datasets to pickle files\ndef write_dataset_to_file(dataset, filename):\n with open(filename, 'wb') as file:\n pickle.dump(dataset, file)\n\nwrite_dataset_to_file(training_dataset, 'training_dataset_5k.pkl')\n#write_dataset_to_file(validation_dataset, 'validation_dataset.pkl')\n#write_dataset_to_file(test_dataset_05k, 'test_dataset_1k.pkl')\n#write_dataset_to_file(test_dataset_1k, 'test_dataset_2k.pkl')\n#write_dataset_to_file(test_dataset_5k, 'test_dataset_5k.pkl')\n#write_dataset_to_file(test_dataset_10k, 'test_dataset_10k.pkl')\n#write_dataset_to_file(test_dataset_100k, 'test_dataset_100k.pkl')\n\n\n#test_dataset_5k = read_dataset_from_file('test_dataset_5k.pkl')\n#test_dataset_10k = read_dataset_from_file('test_dataset_10k.pkl')\n#test_dataset_100k = read_dataset_from_file('test_dataset_100k.pkl')\nprint(test_dataset_5k)\n\n\n" }, { "path": "examples/bp_online_localLLM/runEoH.py", "content": "from eoh import eoh\nfrom eoh.utils.getParas import Paras\n\n# Parameter initilization #\nparas = Paras() \n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = \"bp_online\", #['tsp_construct','bp_online']\n llm_use_local = True, # set your LLM endpoint\n llm_local_url = \"http://xxx/completions\", # set your url for local deployment\n ec_pop_size = 4, # number of samples in each population\n ec_n_pop = 4, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False)\n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()" }, { "path": "examples/tsp_construct/evaluation/evaluation.py", "content": "import numpy as np\nimport matplotlib.pyplot as plt\nimport importlib\nimport time\n\n\nclass Evaluation():\n def __init__(self,problem_size,dataset,n_test,debug_mode=False) -> None:\n\n self.ndelay = 1\n self.problem_size = problem_size\n self.neighbor_size = problem_size\n self.n_instance = n_test\n \n self.instance_data = dataset\n\n\n def tour_cost(self,instance, solution, problem_size):\n cost = 0\n for j in range(problem_size - 1):\n cost += np.linalg.norm(instance[int(solution[j])] - instance[int(solution[j + 1])])\n cost += np.linalg.norm(instance[int(solution[-1])] - instance[int(solution[0])])\n return cost\n\n def generate_neighborhood_matrix(self,instance):\n instance = np.array(instance)\n n = len(instance)\n neighborhood_matrix = np.zeros((n, n), dtype=int)\n\n for i in range(n):\n distances = np.linalg.norm(instance[i] - instance, axis=1)\n sorted_indices = np.argsort(distances) # sort indices based on distances\n neighborhood_matrix[i] = sorted_indices\n\n return neighborhood_matrix\n \n\n def route_plot(self, instance, route):\n LLM_route = np.array([instance[int(node_id)] for node_id in route])\n\n # Plot LLM_route and opt_route\n plt.figure(figsize=(8, 6))\n plt.plot(LLM_route[:, 0], LLM_route[:, 1], 'b-', linewidth=0.5, label='route')\n plt.scatter(LLM_route[:, 0], LLM_route[:, 1], c='b', s=10, label='nodes')\n\n # Display visited number above each node with larger font size\n for i, (x, y) in enumerate(LLM_route):\n plt.text(x, y, i + 1, ha='center', va='bottom', fontsize=6)\n\n # Add labels and legend with larger font size\n plt.xlabel('X coordinate', fontsize=14)\n plt.ylabel('Y coordinate', fontsize=14)\n plt.legend(fontsize=12)\n\n # Adjust the margin in the boundary\n plt.tight_layout()\n\n # Save the figure\n plt.savefig('route_plot.pdf')\n plt.savefig('route_plot.jpg')\n\n # Show the figure\n plt.show()\n\n\n def evaluate(self):\n \n heuristic_module = importlib.import_module(\"heuristic\")\n eva = importlib.reload(heuristic_module) \n\n dis = np.zeros(self.n_instance)\n n_ins = 0\n for instance, distance_matrix in self.instance_data:\n if n_ins == self.n_instance: break\n\n # get neighborhood matrix, we do not need it \n neighbor_matrix = self.generate_neighborhood_matrix(instance)\n\n destination_node = 0\n\n current_node = 0\n\n route = np.zeros(self.problem_size)\n #print(\">>> Step 0 : select node \"+str(instance[0][0])+\", \"+str(instance[0][1]))\n for i in range(1,self.problem_size-1):\n\n near_nodes = neighbor_matrix[current_node][1:]\n\n mask = ~np.isin(near_nodes,route[:i])\n\n unvisited_near_nodes = near_nodes[mask]\n\n unvisited_near_size = np.minimum(self.neighbor_size,unvisited_near_nodes.size)\n\n unvisited_near_nodes = unvisited_near_nodes[:unvisited_near_size]\n\n next_node = eva.select_next_node(current_node, destination_node, unvisited_near_nodes, distance_matrix)\n\n current_node = next_node\n\n route[i] = current_node\n\n #print(\">>> Step \"+str(i)+\": select node \"+str(instance[current_node][0])+\", \"+str(instance[current_node][1]))\n\n mask = ~np.isin(np.arange(self.problem_size),route[:self.problem_size-1])\n\n last_node = np.arange(self.problem_size)[mask]\n\n current_node = last_node[0]\n\n route[self.problem_size-1] = current_node\n\n distance = self.tour_cost(instance,route,self.problem_size)\n\n dis[n_ins] = distance\n\n n_ins += 1\n\n\n ave_dis = np.average(dis)\n\n return ave_dis\n\n\n\n\n" }, { "path": "examples/tsp_construct/evaluation/heuristic.py", "content": "# example heuristic\n# replace it with your own heuristic designed by EoH\nimport numpy as np\ndef select_next_node(current_node, destination_node, unvisited_nodes, distance_matrix):\n next_node_id = np.argmin([distance_matrix[current_node][i] for i in unvisited_nodes if i != current_node])\n next_node = unvisited_nodes[next_node_id]\n return next_node" }, { "path": "examples/tsp_construct/evaluation/results.txt", "content": "Average dis on 100 instance with size 20 is: 4.558 timecost: 0.122\nAverage dis on 100 instance with size 50 is: 7.014 timecost: 0.398\nAverage dis on 100 instance with size 100 is: 9.811 timecost: 0.932\n" }, { "path": "examples/tsp_construct/evaluation/runEval.py", "content": "# -------\n# Evaluaiton code for EoH on TSP\n#--------\n# More results may refer to \n# Liu, Fei, Xialiang Tong, Mingxuan Yuan, and Qingfu Zhang.\n# \"Algorithm evolution using large language model.\" \n# arXiv preprint arXiv:2311.15249 (2023).\n\n\nfrom evaluation import Evaluation\nimport pickle\nimport time\n\ndebug_mode = False\n# problem_size = [10,20,50,100,200]\nproblem_size = [20,50,100]\nn_test_ins = 64\nprint(\"Start evaluation...\")\nwith open(\"results.txt\", \"w\") as file:\n for size in problem_size:\n instance_file_name = './testingdata/instance_data_' + str(size)+ '.pkl'\n with open(instance_file_name, 'rb') as f:\n instance_dataset = pickle.load(f)\n\n eva = Evaluation(size,instance_dataset,n_test_ins,debug_mode)\n\n time_start = time.time()\n gap = eva.evaluate()\n\n result = (f\"Average dis on {n_test_ins} instance with size {size} is: {gap:7.3f} timecost: {time.time()-time_start:7.3f}\")\n print(result)\n file.write(result + \"\\n\")\n \n\n\n" }, { "path": "examples/tsp_construct/runEoH.py", "content": "from eoh import eoh\nfrom eoh.utils.getParas import Paras\n\n# Parameter initilization #\nparas = Paras() \n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = \"tsp_construct\", #['tsp_construct','bp_online']\n llm_api_endpoint = \"XXX\u0003\", # set your LLM endpoint\n llm_api_key = \"XXX\", # set your key\n llm_model = \"gpt-3.5-turbo\",\n ec_pop_size = 4, # number of samples in each population\n ec_n_pop = 4, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False)\n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()" }, { "path": "examples/user_bo_caf/best_alg.py", "content": "import torch\nimport torch.distributions as tdist\n\ndef utility(train_x, train_y, best_x, best_y, test_x, mean_test_y, std_test_y, cost_test_y, budget_used, budget_total):\n\n # Calculate the expected improvement (EI) for each test input \n with torch.no_grad():\n z = (mean_test_y - best_y) / torch.sqrt(torch.pow(std_test_y, 2) + torch.pow(train_y.std(), 2)) \n ei = (mean_test_y - best_y) * tdist.Normal(0, 1).cdf(z) + torch.sqrt(torch.pow(std_test_y, 2) + torch.pow(train_y.std(), 2)) * tdist.Normal(0, 1).log_prob(z).exp()\n \n # Calculate the reduction in uncertainty through mutual information \n with torch.no_grad(): \n mi = torch.max(torch.tensor(0), (torch.log(torch.pow(std_test_y, 2) + torch.pow(train_y.std(), 2)) - torch.log(torch.pow(train_y.std(), 2))) / 2) \n \n # Adjust the utility value based on the reduction in uncertainty, cost of evaluation, and remaining budget \n utility_value = (ei * (1 - mi)) - torch.exp(-cost_test_y) * (budget_total - budget_used) \n \n # Calculate the distance of the test input from the known solutions \n distance_to_known = torch.cdist(test_x, train_x) \n \n # Adjust the utility value based on the diversity and coverage of the unobserved test input space \n diversity_coverage_factor = torch.mean(torch.min(distance_to_known, dim=1).values) \n \n utility_value += diversity_coverage_factor \n \n return utility_value\n " }, { "path": "examples/user_bo_caf/instance/instance_generator.py", "content": "from botorch.test_functions import Hartmann, Ackley, Cosine8, Rastrigin, \\\nRosenbrock, Levy, Powell, Shekel, ThreeHumpCamel, StyblinskiTang, Griewank\nimport torch\nimport pickle\n\ndevice = torch.device(\"cpu\")\ndtype = torch.double\n\nreal_problem_list = [\nAckley(dim=2, negate=True).to(device=device, dtype=dtype),\nRastrigin(dim=2, negate=True).to(device=device, dtype=dtype),\n# Griewank(negate=True).to(device=device, dtype=dtype),\n#Rosenbrock(dim=2, negate=True).to(device=device, dtype=dtype),\n# Levy(negate=True).to(device=device, dtype=dtype),\n# ThreeHumpCamel(negate=True).to(device=device, dtype=dtype),\n# StyblinskiTang(negate=True).to(device=device, dtype=dtype),\n# Hartmann(dim=3, negate=True).to(device=device, dtype=dtype),\n# Powell(negate=True).to(device=device, dtype=dtype),\n# Shekel(negate=True).to(device=device, dtype=dtype),\n# Hartmann(dim=6, negate=True).to(device=device, dtype=dtype),\n# Cosine8(negate=False).to(device=device, dtype=dtype),\n]\n\n# Save the real_problem_list to a pickle file\nwith open(\"instance/botorch_problem.pkl\", \"wb\") as f:\n pickle.dump(real_problem_list, f)" }, { "path": "examples/user_bo_caf/prob.py", "content": "import numpy as np\nimport importlib\nimport pickle\nimport torch\nfrom torch import Tensor\nfrom botorch.utils.transforms import convert_to_target_pre_hook, t_batch_mode_transform\nfrom botorch.acquisition import AnalyticAcquisitionFunction, ExpectedImprovement\nfrom botorch.utils.transforms import unnormalize, normalize\nfrom torch.quasirandom import SobolEngine\nfrom botorch.models import SingleTaskGP\nfrom gpytorch.mlls import ExactMarginalLogLikelihood\nfrom botorch.fit import fit_gpytorch_mll\nfrom botorch.optim import optimize_acqf\nfrom abc import ABC, abstractmethod\nfrom botorch.models.transforms import Log\nfrom botorch.exceptions import BadInitialCandidatesWarning\nfrom botorch.exceptions import OptimizationWarning\nfrom prompts import GetPrompts\nimport types\nimport sys\nimport warnings\nwarnings.filterwarnings('ignore', category=BadInitialCandidatesWarning)\nwarnings.filterwarnings('ignore', category=RuntimeWarning)\nwarnings.filterwarnings(\"ignore\", category=OptimizationWarning)\n\nfrom joblib import Parallel, delayed\n\ndevice = torch.device(\"cpu\")\ndtype = torch.double\n\nclass CostModel(torch.nn.Module, ABC):\n \"\"\"\n Simple abstract class for a cost model.\n \"\"\" \n \n @abstractmethod\n def forward(self, X):\n pass\n \n\nclass CostModelGP(CostModel):\n \"\"\"\n A basic cost model that assumes the cost is positive.\n It models the log cost to guarantee positive cost predictions.\n \"\"\"\n\n def __init__(self, X, Y_cost):\n assert torch.all(Y_cost > 0)\n super().__init__()\n gp = SingleTaskGP(train_X=X, train_Y=Y_cost, outcome_transform=Log())\n mll = ExactMarginalLogLikelihood(likelihood=gp.likelihood, model=gp)\n fit_gpytorch_mll(mll)\n self.gp = gp\n\n def forward(self, X):\n return torch.exp(self.gp(X).mean)\n\nclass CustomAF(AnalyticAcquisitionFunction):\n def __init__(self, alg, model, cost_model, \n train_x, train_Y, best_x, best_Y,\n budget_used, budget_total):\n super().__init__(model=model)\n self.alg = alg\n self.model = model\n self.cost_model = cost_model\n self.train_x = train_x\n self.train_Y = train_Y\n self.best_x = best_x\n self.best_Y = best_Y\n self.budget_used = budget_used\n self.budget_total = budget_total\n\n @t_batch_mode_transform(expected_q=1)\n def forward(self, test_x: Tensor) -> Tensor:\n mean_test_y, std_test_y = self._mean_and_sigma(test_x)\n test_x_sqz = test_x.squeeze(dim=1)\n cost_test_y = self.cost_model(test_x_sqz)\n\n # compute the utility value\n utility_value = self.alg.utility(self.train_x, self.train_Y, \n self.best_x, self.best_Y, \n test_x_sqz, mean_test_y, std_test_y, \n cost_test_y, self.budget_used, self.budget_total)\n\n return utility_value\n\nclass ExpectedImprovementWithCost(AnalyticAcquisitionFunction):\n \"\"\"\n This is the acquisition function EI(x) / c(x) ^ alpha, where alpha is a decay\n factor that reduces or increases the emphasis of the cost model c(x).\n \"\"\"\n\n def __init__(self, model, cost_model, best_f, budget_init, budget_used, budget_total):\n super().__init__(model=model)\n self.model = model\n self.cost_model = cost_model\n self.ei = ExpectedImprovement(model=model, best_f=best_f)\n self.alpha = (budget_total-budget_used) / (budget_total-budget_init)\n\n def forward(self, X):\n return self.ei(X) / torch.pow(self.cost_model(X)[:, 0], self.alpha)\n\n\nclass Evaluation():\n def __init__(self) -> None:\n self.prompts = GetPrompts()\n \n with open('./instance/botorch_problem.pkl', 'rb') as f:\n self.instance_data = pickle.load(f)\n\n self.n_instance = len(self.instance_data)\n\n def eval_objective(self, real_problem,x):\n \"\"\"unnormalize and evalaute a point with objective function\"\"\"\n obj = real_problem(unnormalize(x, real_problem.bounds))\n return obj.to(dtype=dtype, device=device)\n\n def eval_cost(self, real_problem,x):\n \"\"\"evalaute a point with cost function\"\"\"\n x_optimal_unnorm = normalize(real_problem.optimizers, real_problem.bounds)\n cost = torch.exp(-torch.norm(x - x_optimal_unnorm, p=2, dim=1))\n\n return cost.to(dtype=dtype, device=device)\n\n def get_initial_points(self, dim, n_pts, seed=0):\n sobol = SobolEngine(dimension=dim, scramble=True, seed=seed)\n X_init = sobol.draw(n=n_pts).to(dtype=dtype, device=device)\n return X_init\n\n def EGO(self, code_string, cost_total, real_problem, random_seed):\n with warnings.catch_warnings():\n warnings.filterwarnings(\"ignore\")\n\n # Create a new module object\n heuristic_module = types.ModuleType(\"heuristic_module\")\n # Execute the code string in the new module's namespace\n exec(code_string, heuristic_module.__dict__)\n # Add the module to sys.modules so it can be imported\n sys.modules[heuristic_module.__name__] = heuristic_module\n alg = heuristic_module\n\n # DoE\n dim = real_problem.dim\n n_init = 2 * dim\n torch.manual_seed(random_seed)\n X_ei = self.get_initial_points(dim, n_init,seed=random_seed)\n Y_ei = self.eval_objective(real_problem,X_ei).unsqueeze(-1) # (n,1)\n Y_cost = self.eval_cost(real_problem,X_ei).unsqueeze(-1) # (n,1)\n \n # build initial obj model\n train_Y = (Y_ei - Y_ei.mean()) / Y_ei.std()\n model = SingleTaskGP(X_ei, train_Y)\n mll = ExactMarginalLogLikelihood(model.likelihood, model)\n fit_gpytorch_mll(mll)\n\n # build initial cost model\n cost_model = CostModelGP(X_ei, Y_cost)\n cost_init = (torch.cumsum(Y_cost[:, 0], dim=0))[-1].item()\n cost_used = (torch.cumsum(Y_cost[:, 0], dim=0))[-1].item()\n\n # optimize loop\n while cost_used < cost_total:\n best_Y=train_Y.max()[None]\n best_index = train_Y.argmax()\n best_x = X_ei[best_index,None]\n \n # choose af\n # EvolCAF\n ei = CustomAF(alg, model, cost_model, \n X_ei, train_Y, best_x, best_Y,\n budget_used=cost_used, budget_total=cost_total)\n # EI-cool\n # ei = ExpectedImprovementWithCost(model,cost_model,best_Y,\n # budget_init=cost_init, budget_used=cost_used, budget_total=cost_total)\n # EIpu\n # ei = ExpectedImprovementWithCost(model,cost_model,best_Y,\n # budget_init=0, budget_used=0, budget_total=cost_total)\n # # EI\n # ei = ExpectedImprovement(model, best_f=train_Y.max())\n \n # optimize af\n candidate, acq_value = optimize_acqf( # candidate (1,dim)\n ei,\n bounds=torch.stack(\n [\n torch.zeros(dim, dtype=dtype, device=device),\n torch.ones(dim, dtype=dtype, device=device),\n ]\n ),\n q=1, # sequential\n num_restarts=20,\n raw_samples=100,\n )\n\n # evaluate candidates\n Y_next = self.eval_objective(real_problem,candidate).unsqueeze(-1) # (1,1)\n Y_cost_next = self.eval_cost(real_problem,candidate).unsqueeze(-1) # (1,1)\n\n # append data\n X_ei = torch.cat((X_ei, candidate), axis=0)\n Y_ei = torch.cat((Y_ei, Y_next), axis=0)\n Y_cost = torch.cat((Y_cost, Y_cost_next), axis=0)\n\n # update obj model\n train_Y = (Y_ei - Y_ei.mean()) / Y_ei.std()\n model = SingleTaskGP(X_ei, train_Y)\n mll = ExactMarginalLogLikelihood(model.likelihood, model)\n fit_gpytorch_mll(mll)\n\n # update cost model\n cost_model = CostModelGP(X_ei, Y_cost)\n cost_used = (torch.cumsum(Y_cost[:, 0], dim=0))[-1].item()\n\n best_value = torch.tensor(Y_ei.max().item())\n gap = (torch.abs(real_problem.optimal_value-best_value)).numpy()\n\n return gap\n \n def EvalEGO(self,code_string):\n N_TRIALS = 10\n #num_cores = multiprocessing.cpu_count()\n time_limit = 60 # maximum 60 seconds for BO loop when training, can be set much larger when testing other AFs\n gap_all = Parallel(n_jobs=20, timeout=time_limit)(\n delayed(self.EGO)(code_string, cost_total=30, \n real_problem=instance, random_seed=trial)\n for trial in range(1, N_TRIALS + 1)\n for instance in self.instance_data\n )\n gap_all = np.array(gap_all).reshape(N_TRIALS, len(self.instance_data))\n gap_mean = np.mean(gap_all).astype(np.float64) # scalar\n return gap_mean \n \n def evaluate(self, code_string):\n try:\n # Suppress warnings\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n fitness = self.EvalEGO(code_string)\n print(\"fitness:\",fitness)\n return fitness\n except Exception as e:\n #print(\"Error:\", str(e))\n return None\n\nif __name__ == \"__main__\":\n import inspect\n interface_eval = Evaluation()\n heuristic_module = importlib.import_module(\"best_alg\")\n eva = importlib.reload(heuristic_module)\n source_code = inspect.getsource(eva)\n print(source_code)\n fitness = interface_eval.evaluate(source_code)" }, { "path": "examples/user_bo_caf/prompts.py", "content": "class GetPrompts():\n def __init__(self):\n self.prompt_task = \"Given a black-box maximization optimization problem with unknown heterogenous cost of evaluation, \\\nsuppose I have trained the surrogate and cost model based on the evaluated samples, \\\nyou need to create a totally new utility (different from the utilities in the literature) \\\nthat quantifies the benefit of the given unobserved test input and budget information in each iteration. \"\n self.prompt_func_name = \"utility\"\n self.prompt_func_inputs = [\"train_x\",\"train_y\",\"best_x\",\"best_y\",\"test_x\",\"mean_test_y\",\"std_test_y\",\n \"cost_ test_y\",\"budget_used\",\"budget_total\"]\n self.prompt_func_outputs = [\"utility_value\"]\n self.prompt_inout_inf = \"The meanings of above inputs are: evaluated historical inputs and function values, \\\nthe best optimal solution and corresponding maximum function values so far, the unobserved test input, \\\nthe predicted mean and std of the function value at the unobserved test input, the cost spent when observing the test input, \\\nthe budget has been used and the total given budget, respectively. The output is the utility value. \\\nAll the inputs and output are torch.tensor with dtype=torch.float64. \\\nThe input sizes are (n_train,dim), (n_train,1), (1,dim), (1), (n_test, dim), (n_test), (n_test), (n_test), (1), (1), respectively. \\\nThe output size is (n_test). Here n_train is the number of evaluated samples, dim is the dimension of input variables, n_test is the number of test points.\"\n self.prompt_other_inf = \"You must make sure the size of returned output utility_value is (n_test), \\\nso pay attention to the sizes of new variables you created in the code. You can use any mathematical operation on the inputs, \\\nplease try to be creative and make full use of the inputs information.\"\n\n def get_task(self):\n return self.prompt_task\n \n def get_func_name(self):\n return self.prompt_func_name\n \n def get_func_inputs(self):\n return self.prompt_func_inputs\n \n def get_func_outputs(self):\n return self.prompt_func_outputs\n \n def get_inout_inf(self):\n return self.prompt_inout_inf\n\n def get_other_inf(self):\n return self.prompt_other_inf" }, { "path": "examples/user_bo_caf/readme.md", "content": "#### EvolCAF\n\n\"EvolCAF\"\n\nEvolCAF is a novel framework that integrates large language models (LLMs) with evolutionary computation (EC) to automatically design acquisition functions (AFs) to enhance cost-aware Bayesian optimization (BO). \n\nLeveraging the crossover and mutation in the algorithm space, EvolCAF offers a novel design paradigm, significantly reduces the reliance on domain expertise and model training. The designed cost-aware AF maximizes the utilization of available information from historical data, surrogate models and budget details. It introduces novel ideas not previously explored in the existing literature on acquisition function design, allowing for clear interpretations to provide insights into its behavior and decision-making process.\n\n\n\n#### Requirements\n\n- [EoH](https://github.com/FeiLiu36/EoH)\n- [BoTorch](https://github.com/pytorch/botorch)==0.9.2\n\n#### Quick Start\n+ Install [EoH](https://github.com/FeiLiu36/EoH)\n+ Python runEoH.py\n\n#### Cite the work\n\nEvolCAF was introduced in\n\n```\n@article{yao2024evolve,\n title={Evolve Cost-aware Acquisition Functions Using Large Language Models},\n author={Yao, Yiming and Liu, Fei and Cheng, Ji and Zhang, Qingfu},\n journal={International Conference on Parallel Problem Solving From Nature (PPSN)},\n year={2024}\n}\n```\n\nEoH was introduced in\n\n```\n@inproceedings{liu2024evolution,\n title={Evolution of Heuristics: Towards Efficient Automatic Algorithm Design Using Large Language Model},\n author={Liu, Fei and Tong, Xialiang and Yuan, Mingxuan and Lin, Xi and Luo, Fu and Wang, Zhenkun and Lu, Zhichao and Zhang, Qingfu},\n booktitle={Proceedings of International Conference on Machine Learning},\n year={2024}\n}\n```\n" }, { "path": "examples/user_bo_caf/runEoH.py", "content": "from eoh import eoh\nfrom eoh.utils.getParas import Paras\nfrom prob import Evaluation\n\n# Parameter initilization #\nparas = Paras() \n\n# Set your local problem\nproblem_local = Evaluation()\n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = problem_local, # Set local problem, else use default problems\n llm_api_endpoint = \"XXX\", # set your LLM endpoint\n llm_api_key = \"XXX\", # set your key\n llm_model = \"gpt-3.5-turbo-1106\",\n ec_pop_size = 4, # number of samples in each population\n ec_n_pop = 4, # number of populations\n exp_n_proc = 1, # multi-core parallel\n exp_debug_mode = False,\n eva_numba_decorator = False)\n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()" }, { "path": "examples/user_bp_online/get_instance.py", "content": "import numpy as np\nimport pickle\nclass GetData():\n def __init__(self) -> None:\n self.datasets = {}\n # Data from the Weibull 5k test dataset, containing 5 bin packing instances\n # each with 5,000 items.\n self.datasets['Weibull 5k'] = {'test_0': {'capacity': 100, 'num_items': 5000, 'items': [48, 66, 48, 32, 72, 37, 41, 21, 58, 35, 18, 53, 52, 42, 51, 30, 42, 44, 58, 62, 28, 20, 27, 53, 59, 56, 46, 60, 21, 49, 29, 58, 31, 47, 34, 41, 28, 49, 22, 37, 31, 27, 50, 46, 39, 52, 40, 41, 31, 57, 53, 57, 35, 39, 38, 40, 34, 22, 30, 48, 34, 34, 48, 53, 23, 57, 50, 67, 18, 40, 38, 38, 42, 53, 38, 37, 53, 62, 22, 51, 34, 51, 24, 92, 60, 29, 39, 49, 24, 33, 67, 65, 62, 57, 60, 29, 53, 29, 54, 52, 37, 59, 55, 69, 20, 41, 47, 44, 36, 48, 61, 33, 53, 36, 47, 38, 39, 35, 41, 31, 42, 41, 45, 49, 25, 20, 71, 61, 35, 33, 42, 11, 39, 68, 43, 30, 51, 31, 68, 29, 40, 45, 41, 23, 46, 65, 37, 60, 45, 38, 28, 45, 42, 30, 39, 59, 36, 60, 58, 32, 49, 19, 55, 46, 55, 53, 46, 32, 56, 29, 23, 22, 26, 19, 37, 24, 50, 44, 33, 27, 26, 34, 38, 21, 58, 48, 66, 37, 40, 10, 37, 27, 56, 30, 49, 19, 52, 17, 41, 29, 38, 53, 21, 36, 37, 23, 35, 26, 25, 33, 11, 34, 18, 69, 36, 50, 40, 19, 65, 51, 53, 35, 35, 45, 21, 27, 60, 35, 56, 14, 65, 40, 24, 39, 49, 85, 54, 32, 28, 27, 9, 28, 44, 47, 65, 59, 23, 46, 36, 46, 18, 20, 20, 36, 50, 71, 57, 63, 31, 35, 47, 35, 35, 41, 48, 19, 53, 69, 26, 43, 45, 27, 52, 19, 49, 45, 29, 32, 29, 22, 52, 15, 47, 39, 26, 41, 27, 31, 63, 50, 21, 30, 21, 42, 43, 21, 71, 21, 34, 29, 80, 41, 37, 51, 35, 33, 45, 26, 44, 30, 41, 22, 55, 26, 43, 35, 15, 31, 32, 53, 36, 33, 25, 19, 29, 64, 56, 17, 30, 13, 66, 19, 39, 51, 38, 39, 54, 37, 37, 17, 8, 45, 58, 19, 48, 51, 41, 53, 69, 33, 37, 29, 25, 41, 54, 51, 26, 29, 66, 60, 36, 33, 17, 31, 48, 73, 16, 26, 46, 25, 25, 33, 57, 49, 28, 62, 44, 22, 19, 65, 25, 60, 39, 39, 36, 45, 40, 45, 43, 28, 45, 28, 54, 44, 54, 32, 62, 67, 34, 31, 29, 47, 38, 35, 69, 57, 40, 20, 37, 27, 56, 25, 57, 54, 36, 45, 56, 49, 35, 77, 71, 53, 46, 41, 25, 50, 50, 44, 79, 52, 19, 44, 43, 36, 40, 36, 36, 35, 51, 35, 41, 67, 47, 46, 13, 53, 56, 37, 41, 46, 36, 70, 29, 18, 35, 59, 7, 51, 36, 52, 24, 40, 21, 74, 21, 23, 28, 47, 43, 40, 50, 61, 65, 17, 59, 60, 52, 53, 19, 51, 63, 59, 25, 42, 50, 50, 60, 61, 27, 37, 25, 55, 69, 45, 51, 36, 47, 20, 56, 39, 20, 43, 50, 34, 42, 37, 60, 48, 18, 41, 42, 35, 34, 46, 20, 61, 57, 25, 42, 72, 16, 39, 29, 64, 37, 44, 39, 32, 47, 61, 23, 41, 21, 38, 33, 67, 60, 54, 66, 51, 70, 39, 34, 47, 16, 38, 48, 54, 15, 34, 34, 14, 22, 25, 32, 11, 19, 44, 32, 36, 43, 20, 55, 46, 38, 62, 43, 35, 19, 47, 31, 17, 42, 31, 39, 49, 37, 53, 36, 64, 29, 19, 42, 47, 45, 9, 45, 52, 59, 35, 67, 25, 27, 55, 44, 47, 38, 17, 24, 61, 68, 35, 36, 18, 23, 50, 20, 36, 35, 48, 32, 29, 62, 23, 32, 36, 25, 15, 57, 50, 43, 43, 30, 24, 56, 52, 65, 17, 48, 29, 64, 52, 20, 45, 60, 54, 38, 57, 27, 32, 20, 44, 18, 18, 32, 38, 36, 39, 17, 41, 42, 67, 39, 21, 30, 61, 40, 43, 31, 16, 40, 41, 38, 38, 11, 43, 40, 17, 41, 65, 48, 42, 47, 24, 86, 26, 29, 48, 34, 19, 55, 65, 53, 68, 43, 41, 28, 50, 49, 15, 42, 26, 14, 45, 26, 61, 54, 25, 44, 28, 43, 43, 18, 44, 21, 52, 47, 38, 32, 55, 54, 24, 75, 38, 53, 24, 24, 39, 63, 32, 47, 32, 67, 32, 43, 25, 52, 47, 48, 50, 56, 18, 48, 64, 66, 37, 36, 42, 30, 37, 53, 32, 73, 40, 55, 30, 38, 34, 60, 39, 22, 43, 32, 13, 44, 41, 23, 48, 28, 42, 22, 34, 49, 55, 27, 34, 38, 43, 35, 71, 61, 44, 32, 22, 27, 82, 38, 50, 30, 54, 29, 48, 45, 45, 42, 64, 36, 44, 26, 52, 12, 32, 46, 50, 23, 56, 54, 23, 47, 46, 38, 60, 45, 38, 58, 48, 53, 37, 34, 45, 25, 38, 32, 11, 46, 38, 32, 42, 58, 59, 12, 50, 49, 44, 46, 37, 53, 58, 47, 34, 45, 39, 58, 31, 29, 36, 38, 36, 49, 56, 45, 34, 28, 7, 31, 42, 15, 49, 51, 47, 26, 20, 52, 26, 50, 32, 34, 33, 51, 73, 17, 45, 40, 35, 24, 30, 46, 42, 21, 11, 49, 32, 67, 50, 47, 54, 44, 57, 55, 36, 51, 37, 26, 35, 20, 42, 32, 46, 30, 33, 44, 67, 23, 47, 45, 39, 14, 37, 41, 29, 59, 53, 21, 15, 49, 37, 56, 19, 28, 48, 41, 30, 27, 32, 10, 83, 58, 22, 40, 46, 52, 34, 34, 43, 22, 17, 28, 67, 58, 35, 33, 18, 11, 44, 35, 20, 60, 50, 44, 23, 49, 29, 44, 66, 37, 44, 15, 62, 27, 41, 52, 32, 44, 28, 11, 32, 28, 72, 35, 21, 54, 42, 57, 37, 26, 37, 43, 49, 24, 57, 37, 37, 41, 19, 27, 40, 49, 50, 14, 59, 61, 34, 35, 53, 33, 36, 31, 42, 32, 60, 20, 46, 41, 31, 12, 59, 22, 60, 53, 22, 58, 19, 27, 23, 37, 32, 42, 58, 24, 38, 29, 26, 57, 17, 34, 34, 17, 35, 61, 48, 45, 31, 38, 22, 47, 38, 25, 47, 47, 43, 38, 46, 52, 45, 39, 64, 21, 35, 31, 32, 44, 46, 31, 75, 48, 23, 47, 31, 34, 22, 24, 50, 28, 32, 23, 49, 53, 51, 30, 70, 36, 28, 54, 14, 61, 61, 37, 24, 38, 34, 43, 26, 38, 44, 55, 42, 33, 35, 29, 28, 18, 19, 51, 39, 28, 54, 43, 43, 41, 27, 29, 17, 14, 44, 46, 77, 55, 34, 61, 45, 29, 24, 32, 38, 15, 72, 9, 19, 25, 59, 21, 53, 13, 42, 38, 29, 30, 39, 59, 41, 13, 38, 46, 21, 49, 41, 28, 19, 61, 24, 15, 52, 34, 23, 55, 31, 36, 54, 45, 66, 69, 37, 54, 69, 50, 62, 15, 49, 29, 56, 25, 64, 30, 34, 25, 23, 46, 52, 59, 40, 58, 59, 58, 57, 21, 25, 44, 28, 41, 44, 13, 17, 81, 29, 68, 61, 42, 38, 66, 10, 57, 49, 63, 31, 67, 63, 20, 65, 35, 14, 73, 55, 37, 69, 46, 48, 24, 39, 42, 45, 27, 48, 43, 24, 30, 41, 24, 43, 49, 45, 61, 56, 43, 39, 59, 61, 36, 22, 54, 38, 73, 44, 26, 49, 50, 44, 44, 30, 26, 16, 46, 29, 25, 54, 26, 52, 63, 61, 23, 23, 44, 31, 48, 27, 32, 28, 33, 46, 41, 35, 29, 56, 62, 81, 58, 67, 7, 46, 79, 36, 18, 37, 48, 34, 48, 56, 38, 18, 27, 33, 53, 21, 37, 43, 31, 50, 27, 39, 25, 41, 58, 24, 46, 43, 62, 28, 51, 20, 65, 57, 70, 15, 31, 73, 13, 32, 64, 32, 17, 60, 37, 35, 27, 49, 38, 42, 37, 49, 26, 51, 66, 19, 20, 63, 44, 21, 40, 44, 65, 44, 50, 51, 26, 45, 53, 46, 35, 65, 26, 62, 37, 24, 64, 13, 60, 54, 46, 37, 31, 48, 29, 18, 31, 12, 45, 31, 29, 31, 32, 35, 40, 40, 26, 41, 55, 21, 14, 47, 54, 41, 64, 13, 17, 68, 28, 11, 47, 65, 35, 25, 56, 68, 48, 25, 67, 43, 38, 10, 56, 31, 69, 42, 61, 45, 40, 54, 34, 32, 48, 65, 52, 58, 40, 28, 21, 20, 53, 41, 28, 45, 25, 69, 47, 38, 62, 30, 47, 16, 35, 61, 29, 29, 32, 76, 51, 50, 38, 58, 33, 48, 48, 48, 19, 22, 66, 42, 53, 35, 17, 30, 27, 45, 24, 52, 14, 32, 63, 44, 34, 31, 72, 28, 43, 17, 40, 58, 54, 25, 38, 41, 46, 22, 34, 26, 56, 31, 29, 19, 56, 46, 38, 57, 40, 30, 46, 36, 61, 34, 39, 52, 49, 8, 56, 49, 21, 30, 23, 34, 43, 50, 49, 70, 53, 19, 47, 48, 47, 22, 22, 49, 33, 53, 28, 39, 55, 32, 41, 31, 24, 30, 32, 42, 33, 31, 54, 38, 22, 63, 42, 29, 54, 50, 56, 39, 49, 38, 40, 33, 42, 61, 59, 22, 26, 41, 19, 71, 54, 46, 31, 47, 45, 21, 53, 40, 31, 67, 45, 66, 37, 21, 38, 45, 34, 41, 41, 45, 32, 46, 66, 60, 43, 41, 31, 56, 64, 39, 65, 19, 70, 38, 66, 28, 35, 26, 35, 20, 60, 31, 52, 30, 28, 26, 34, 50, 50, 57, 33, 48, 18, 28, 20, 68, 43, 41, 19, 36, 58, 56, 27, 48, 14, 45, 52, 31, 65, 40, 31, 19, 58, 43, 67, 16, 55, 60, 25, 43, 44, 29, 76, 50, 32, 55, 21, 37, 51, 64, 60, 41, 22, 31, 37, 30, 60, 33, 57, 40, 32, 10, 36, 33, 75, 47, 18, 64, 50, 32, 29, 41, 17, 38, 64, 58, 57, 44, 29, 50, 21, 66, 42, 40, 20, 39, 25, 44, 42, 18, 57, 46, 29, 42, 11, 17, 49, 38, 22, 3, 43, 34, 38, 21, 65, 44, 24, 28, 58, 51, 73, 34, 35, 36, 64, 59, 54, 16, 22, 39, 35, 18, 40, 50, 29, 43, 41, 11, 27, 49, 86, 49, 27, 44, 28, 19, 31, 31, 78, 23, 25, 44, 17, 34, 36, 22, 39, 6, 31, 41, 34, 37, 35, 36, 62, 65, 18, 25, 42, 39, 61, 41, 61, 55, 58, 32, 56, 44, 37, 35, 39, 41, 39, 58, 59, 45, 42, 50, 46, 76, 62, 27, 50, 50, 66, 30, 59, 34, 9, 32, 12, 30, 47, 32, 30, 48, 41, 33, 71, 39, 47, 49, 20, 28, 67, 29, 35, 28, 17, 45, 72, 48, 26, 52, 26, 71, 34, 60, 27, 64, 20, 54, 34, 57, 38, 68, 38, 45, 54, 21, 39, 41, 13, 39, 31, 22, 53, 44, 52, 18, 41, 22, 34, 30, 29, 12, 38, 62, 51, 61, 11, 35, 46, 33, 49, 9, 38, 50, 35, 38, 52, 42, 68, 48, 69, 50, 56, 40, 55, 34, 66, 25, 34, 25, 28, 53, 51, 40, 51, 77, 26, 29, 42, 36, 44, 43, 39, 62, 54, 42, 34, 7, 59, 65, 21, 39, 51, 57, 25, 28, 47, 37, 33, 66, 47, 31, 52, 46, 25, 51, 41, 41, 24, 47, 41, 47, 42, 65, 56, 40, 39, 68, 9, 50, 53, 27, 59, 49, 38, 38, 52, 29, 15, 46, 40, 47, 40, 45, 21, 36, 31, 27, 35, 48, 50, 54, 21, 32, 47, 29, 24, 35, 37, 38, 40, 51, 52, 56, 29, 17, 40, 51, 41, 28, 16, 55, 38, 25, 43, 43, 58, 55, 63, 46, 24, 26, 35, 48, 56, 20, 48, 54, 43, 24, 48, 29, 43, 24, 1, 44, 45, 27, 62, 41, 30, 32, 69, 39, 45, 45, 42, 22, 43, 25, 7, 32, 38, 49, 42, 50, 53, 61, 45, 53, 52, 50, 40, 56, 31, 47, 27, 46, 51, 18, 35, 23, 25, 35, 37, 49, 38, 44, 36, 35, 54, 28, 59, 48, 34, 42, 57, 39, 44, 49, 42, 47, 40, 37, 35, 59, 3, 55, 43, 32, 60, 17, 15, 39, 34, 28, 52, 21, 39, 32, 61, 50, 57, 46, 58, 52, 49, 43, 34, 30, 25, 69, 58, 28, 34, 40, 25, 40, 25, 42, 42, 35, 42, 30, 33, 19, 38, 49, 65, 45, 57, 6, 32, 45, 48, 73, 26, 47, 28, 66, 36, 38, 44, 53, 29, 48, 40, 59, 47, 53, 43, 39, 55, 59, 42, 33, 45, 47, 30, 30, 30, 40, 57, 63, 48, 50, 69, 56, 40, 37, 31, 55, 75, 47, 18, 34, 35, 46, 19, 20, 25, 47, 13, 32, 57, 40, 24, 38, 16, 46, 9, 24, 44, 51, 46, 25, 54, 17, 33, 41, 21, 50, 45, 48, 33, 32, 35, 33, 43, 18, 56, 61, 83, 48, 21, 36, 73, 34, 32, 38, 19, 55, 37, 62, 61, 47, 74, 47, 41, 31, 47, 52, 81, 54, 42, 47, 45, 61, 25, 36, 57, 27, 42, 61, 35, 52, 87, 61, 21, 20, 28, 50, 20, 23, 57, 67, 64, 17, 38, 42, 18, 47, 34, 64, 22, 41, 44, 38, 19, 12, 31, 36, 45, 49, 54, 40, 29, 26, 33, 39, 36, 43, 32, 34, 32, 13, 37, 45, 67, 36, 43, 53, 19, 53, 33, 29, 36, 47, 45, 47, 21, 34, 23, 43, 26, 16, 35, 48, 31, 47, 53, 34, 31, 65, 50, 47, 18, 8, 38, 48, 40, 27, 46, 55, 22, 23, 62, 29, 50, 20, 64, 51, 46, 49, 40, 27, 47, 31, 33, 28, 42, 52, 41, 33, 25, 33, 27, 23, 52, 43, 47, 7, 14, 41, 50, 33, 38, 20, 49, 39, 55, 47, 43, 22, 24, 63, 29, 65, 24, 27, 21, 57, 34, 42, 29, 28, 74, 31, 25, 45, 26, 10, 45, 5, 35, 15, 33, 18, 27, 58, 51, 48, 18, 56, 34, 44, 48, 36, 49, 87, 48, 57, 35, 23, 51, 24, 33, 34, 39, 42, 20, 37, 47, 52, 31, 27, 12, 41, 37, 80, 33, 61, 79, 71, 47, 70, 60, 60, 29, 42, 50, 27, 32, 57, 41, 27, 31, 62, 37, 30, 53, 46, 40, 33, 62, 39, 31, 74, 25, 55, 36, 71, 59, 28, 8, 28, 23, 53, 13, 31, 10, 56, 50, 43, 22, 53, 63, 33, 34, 50, 30, 34, 38, 36, 29, 31, 22, 42, 74, 37, 50, 39, 42, 29, 62, 38, 16, 58, 18, 49, 58, 50, 23, 36, 36, 53, 47, 57, 77, 45, 44, 11, 32, 22, 48, 49, 25, 61, 59, 69, 21, 44, 69, 45, 41, 22, 44, 40, 53, 43, 27, 46, 21, 47, 26, 24, 35, 38, 46, 59, 66, 48, 45, 42, 36, 47, 45, 18, 49, 5, 27, 33, 58, 78, 16, 23, 19, 34, 16, 46, 48, 36, 28, 56, 49, 53, 43, 27, 42, 41, 39, 23, 24, 20, 30, 12, 68, 30, 59, 29, 17, 29, 39, 51, 47, 59, 50, 52, 23, 18, 78, 67, 16, 50, 49, 19, 55, 31, 47, 50, 66, 45, 35, 33, 39, 42, 42, 49, 42, 62, 46, 56, 31, 43, 36, 38, 34, 61, 50, 55, 42, 34, 31, 38, 21, 52, 33, 65, 46, 26, 55, 35, 19, 60, 69, 47, 24, 22, 45, 40, 43, 66, 49, 32, 21, 15, 51, 50, 20, 69, 15, 36, 31, 49, 18, 41, 21, 48, 18, 47, 11, 46, 45, 19, 60, 53, 28, 15, 24, 47, 49, 40, 40, 65, 56, 54, 61, 61, 25, 39, 61, 30, 47, 49, 31, 27, 23, 51, 37, 47, 46, 36, 19, 45, 22, 46, 31, 48, 8, 44, 20, 15, 12, 52, 30, 24, 40, 19, 54, 70, 58, 55, 25, 48, 49, 49, 23, 60, 23, 44, 39, 28, 57, 55, 58, 44, 27, 36, 53, 32, 18, 36, 58, 41, 25, 43, 46, 18, 40, 35, 55, 46, 37, 23, 16, 56, 26, 32, 34, 61, 68, 48, 43, 35, 40, 51, 30, 22, 41, 25, 43, 63, 44, 50, 27, 38, 32, 30, 20, 46, 63, 6, 50, 32, 47, 59, 29, 48, 30, 72, 19, 41, 34, 21, 24, 29, 43, 46, 36, 68, 37, 41, 66, 52, 19, 50, 36, 26, 26, 41, 19, 48, 71, 37, 72, 22, 42, 54, 33, 20, 63, 56, 30, 44, 44, 49, 60, 45, 63, 14, 44, 40, 66, 36, 22, 46, 13, 42, 27, 9, 63, 48, 73, 38, 32, 9, 28, 60, 53, 50, 39, 36, 51, 37, 59, 49, 53, 37, 44, 48, 42, 29, 65, 37, 54, 35, 22, 10, 40, 36, 35, 25, 43, 59, 4, 33, 18, 23, 50, 33, 60, 48, 27, 18, 47, 55, 51, 63, 45, 56, 50, 57, 44, 22, 55, 34, 48, 43, 39, 27, 41, 31, 33, 21, 27, 34, 29, 37, 27, 48, 44, 55, 55, 33, 51, 52, 70, 51, 29, 71, 42, 51, 49, 27, 35, 36, 38, 43, 38, 59, 50, 52, 33, 54, 62, 28, 41, 23, 44, 25, 21, 61, 54, 35, 19, 54, 31, 38, 21, 50, 46, 26, 47, 46, 32, 48, 48, 39, 37, 24, 33, 19, 51, 34, 51, 27, 56, 35, 34, 33, 57, 33, 10, 48, 30, 49, 61, 37, 70, 40, 35, 35, 30, 27, 52, 38, 52, 57, 36, 43, 15, 27, 50, 55, 14, 37, 40, 71, 69, 26, 43, 31, 47, 43, 41, 44, 24, 17, 29, 64, 26, 27, 82, 17, 35, 53, 16, 22, 20, 34, 52, 32, 50, 51, 17, 28, 34, 42, 58, 23, 28, 30, 69, 37, 57, 52, 41, 29, 40, 58, 63, 66, 24, 39, 88, 44, 50, 31, 15, 51, 68, 24, 34, 34, 37, 51, 27, 64, 34, 50, 40, 43, 42, 47, 39, 30, 23, 23, 23, 51, 39, 27, 46, 64, 49, 50, 15, 15, 31, 29, 33, 50, 52, 24, 45, 41, 52, 61, 30, 40, 34, 51, 46, 36, 17, 50, 27, 47, 52, 54, 23, 64, 48, 40, 57, 11, 49, 29, 23, 62, 43, 66, 24, 16, 57, 10, 16, 20, 57, 23, 52, 34, 46, 29, 57, 48, 37, 45, 13, 47, 41, 42, 45, 65, 18, 50, 43, 40, 52, 49, 52, 29, 43, 37, 57, 79, 45, 51, 68, 33, 36, 30, 42, 37, 66, 40, 42, 44, 34, 59, 36, 34, 26, 44, 32, 36, 53, 44, 50, 24, 32, 13, 33, 23, 33, 35, 32, 49, 38, 54, 17, 39, 20, 45, 77, 53, 69, 22, 56, 50, 10, 44, 38, 56, 62, 35, 47, 65, 37, 58, 38, 31, 57, 22, 46, 19, 21, 55, 53, 39, 29, 45, 26, 49, 40, 41, 34, 36, 10, 51, 49, 40, 34, 16, 51, 26, 51, 24, 36, 42, 45, 56, 30, 36, 42, 22, 27, 32, 45, 50, 43, 61, 33, 56, 38, 38, 48, 37, 31, 14, 37, 17, 13, 37, 55, 13, 56, 34, 43, 33, 23, 29, 48, 51, 32, 18, 41, 32, 37, 53, 36, 49, 22, 38, 40, 28, 62, 43, 42, 40, 31, 36, 58, 29, 44, 35, 46, 37, 42, 43, 39, 53, 37, 35, 31, 42, 20, 24, 52, 37, 42, 66, 43, 12, 61, 17, 46, 34, 14, 45, 22, 22, 44, 15, 29, 51, 43, 50, 31, 30, 42, 45, 39, 55, 35, 50, 45, 66, 43, 54, 47, 45, 30, 37, 39, 24, 26, 34, 47, 42, 38, 64, 32, 28, 32, 33, 32, 36, 36, 27, 23, 62, 29, 62, 48, 39, 27, 58, 33, 35, 58, 50, 29, 24, 34, 69, 28, 19, 29, 26, 28, 28, 46, 79, 40, 61, 81, 66, 63, 68, 47, 24, 52, 17, 40, 22, 19, 20, 20, 44, 33, 66, 39, 32, 45, 17, 14, 44, 45, 34, 47, 58, 40, 64, 35, 31, 31, 39, 28, 38, 48, 43, 23, 22, 35, 45, 37, 41, 40, 20, 22, 33, 11, 45, 44, 58, 35, 48, 38, 53, 50, 27, 34, 23, 40, 39, 55, 70, 40, 17, 51, 28, 22, 34, 24, 21, 61, 50, 44, 64, 26, 58, 23, 63, 57, 40, 25, 27, 21, 37, 37, 46, 36, 41, 35, 73, 33, 26, 15, 14, 8, 43, 57, 29, 38, 49, 22, 34, 70, 41, 42, 37, 35, 28, 25, 37, 25, 29, 39, 42, 26, 47, 67, 11, 58, 50, 44, 21, 44, 31, 62, 30, 25, 35, 58, 40, 79, 19, 35, 54, 23, 55, 30, 51, 47, 33, 65, 36, 26, 33, 37, 33, 54, 31, 61, 59, 45, 49, 58, 31, 6, 24, 9, 41, 68, 35, 43, 64, 34, 76, 42, 43, 39, 60, 37, 38, 14, 40, 42, 65, 76, 56, 67, 43, 39, 45, 33, 21, 21, 41, 15, 9, 15, 49, 57, 58, 46, 58, 68, 21, 79, 51, 70, 19, 26, 37, 42, 51, 32, 16, 32, 15, 57, 36, 72, 43, 29, 28, 57, 42, 54, 19, 28, 46, 34, 47, 43, 57, 60, 54, 34, 41, 60, 30, 58, 48, 37, 48, 56, 64, 63, 57, 30, 44, 60, 48, 50, 32, 68, 52, 59, 69, 40, 34, 51, 79, 21, 47, 60, 65, 27, 50, 22, 38, 40, 41, 7, 59, 59, 24, 24, 55, 48, 43, 41, 37, 56, 55, 26, 51, 35, 33, 48, 33, 42, 40, 41, 52, 37, 14, 67, 34, 3, 14, 82, 58, 32, 46, 49, 59, 44, 18, 27, 34, 49, 63, 49, 16, 26, 61, 38, 42, 12, 13, 54, 18, 33, 38, 53, 38, 38, 34, 49, 40, 42, 26, 18, 28, 33, 30, 45, 47, 12, 60, 37, 73, 61, 31, 6, 37, 27, 21, 26, 39, 37, 30, 35, 60, 38, 49, 32, 74, 30, 43, 74, 29, 34, 51, 51, 33, 29, 41, 36, 33, 65, 49, 32, 56, 22, 41, 53, 59, 27, 27, 38, 35, 37, 42, 63, 45, 35, 61, 53, 37, 57, 44, 32, 24, 40, 40, 37, 53, 48, 18, 40, 62, 49, 65, 16, 24, 64, 55, 37, 50, 60, 49, 41, 70, 50, 41, 26, 46, 41, 30, 43, 40, 32, 41, 31, 31, 20, 41, 28, 22, 59, 36, 38, 42, 38, 16, 59, 52, 49, 26, 34, 43, 24, 20, 48, 39, 14, 25, 24, 29, 43, 37, 50, 20, 43, 71, 53, 39, 52, 29, 35, 55, 43, 30, 70, 16, 49, 59, 44, 47, 34, 56, 53, 29, 41, 46, 40, 39, 28, 23, 26, 36, 61, 41, 38, 46, 49, 34, 36, 14, 34, 48, 21, 33, 22, 35, 51, 35, 14, 54, 53, 41, 52, 48, 39, 36, 44, 36, 41, 45, 56, 32, 21, 64, 48, 24, 32, 29, 33, 34, 38, 41, 54, 33, 27, 29, 59, 43, 37, 27, 50, 25, 38, 23, 61, 47, 48, 60, 45, 30, 14, 35, 57, 39, 29, 40, 32, 40, 43, 47, 33, 47, 42, 34, 50, 23, 24, 26, 31, 28, 49, 30, 56, 9, 30, 30, 45, 17, 54, 58, 16, 17, 39, 32, 53, 38, 23, 46, 33, 12, 39, 31, 44, 46, 62, 35, 68, 45, 54, 47, 30, 50, 43, 60, 44, 12, 50, 28, 60, 66, 45, 38, 50, 31, 26, 40, 25, 25, 31, 54, 50, 53, 23, 18, 54, 53, 49, 66, 52, 12, 28, 60, 25, 54, 72, 48, 33, 46, 44, 44, 37, 54, 63, 33, 41, 32, 43, 35, 79, 52, 41, 68, 22, 53, 29, 31, 43, 43, 63, 37, 44, 43, 17, 36, 34, 58, 54, 54, 26, 27, 26, 49, 22, 51, 39, 57, 31, 32, 8, 44, 16, 23, 30, 51, 27, 54, 37, 32, 55, 41, 25, 39, 54, 15, 22, 47, 34, 61, 27, 53, 45, 44, 35, 41, 52, 42, 39, 45, 65, 61, 67, 43, 40, 38, 43, 44, 31, 35, 63, 57, 47, 28, 21, 36, 57, 54, 52, 32, 53, 23, 62, 22, 33, 32, 48, 39, 43, 20, 49, 51, 54, 46, 31, 41, 12, 49, 20, 36, 37, 62, 32, 33, 31, 34, 52, 35, 62, 24, 50, 52, 25, 8, 31, 22, 60, 52, 33, 57, 63, 59, 42, 28, 50, 25, 35, 56, 70, 65, 64, 46, 55, 16, 21, 44, 51, 39, 62, 46, 50, 53, 26, 24, 32, 26, 62, 17, 36, 55, 42, 50, 44, 43, 45, 22, 19, 62, 18, 35, 56, 27, 47, 42, 47, 7, 42, 29, 49, 50, 52, 42, 17, 53, 41, 53, 42, 45, 54, 63, 56, 23, 57, 45, 34, 29, 34, 14, 38, 42, 38, 43, 57, 32, 23, 42, 25, 16, 28, 39, 30, 54, 36, 32, 52, 83, 80, 35, 19, 23, 23, 34, 20, 46, 20, 57, 52, 34, 50, 48, 40, 51, 51, 65, 37, 8, 43, 40, 35, 38, 61, 22, 41, 56, 62, 30, 51, 29, 29, 51, 35, 39, 39, 28, 18, 53, 22, 47, 5, 30, 34, 30, 71, 57, 44, 58, 43, 56, 36, 38, 24, 33, 43, 28, 51, 36, 43, 68, 37, 49, 41, 9, 33, 42, 68, 45, 24, 50, 67, 47, 66, 50, 43, 15, 69, 42, 25, 48, 65, 37, 42, 65, 31, 45, 27, 34, 41, 68, 40, 21, 33, 19, 51, 39, 15, 19, 48, 53, 40, 83, 8, 50, 59, 47, 52, 60, 43, 57, 37, 49, 45, 52, 57, 10, 53, 25, 32, 58, 40, 33, 44, 32, 36, 44, 39, 19, 40, 54, 21, 48, 51, 37, 58, 14, 40, 55, 74, 37, 33, 30, 39, 72, 40, 34, 15, 34, 60, 55, 42, 38, 44, 51, 43, 12, 44, 43, 46, 15, 73, 37, 25, 9, 67, 30, 39, 59, 36, 19, 57, 31, 29, 36, 23, 13, 32, 50, 25, 39, 57, 48, 28, 45, 52, 31, 37, 53, 33, 47, 24, 33, 36, 62, 38, 29, 80, 27, 54, 42, 27, 61, 48, 13, 61, 53, 46, 19, 28, 42, 49, 43, 50, 34, 35, 17, 24, 44, 57, 17, 15, 21, 45, 25, 40, 38, 27, 31, 35, 46, 23, 25, 31, 61, 19, 38, 50, 29, 34, 36, 55, 34, 48, 68, 37, 37, 80, 26, 31, 23, 52, 26, 42, 20, 22, 61, 20, 42, 28, 34, 51, 38, 71, 60, 39, 39, 27, 34, 37, 14, 50, 38, 58, 55, 43, 20, 33, 44, 39, 32, 12, 35, 36, 53, 23, 23, 29, 14, 45, 53, 53, 61, 22, 78, 39, 46, 40, 60, 64, 39, 32, 32, 43, 13, 40, 15, 36, 55, 67, 39, 15, 29, 29, 56, 44, 66, 43, 50, 31, 40, 37, 54, 39, 42, 40, 25, 17, 32, 38, 59, 38, 26, 28, 7, 28, 60, 24, 36, 41, 45, 41, 22, 43, 40, 26, 24, 44, 39, 21, 38, 44, 44, 51, 25, 65, 59, 34, 27, 47, 43, 45, 14, 42, 20, 31, 16, 31, 35, 36, 45, 52, 48, 32, 40, 58, 27, 30, 23, 53, 25, 48, 35, 75, 13, 36, 38, 39, 49, 69, 20, 41, 58, 26, 45, 48, 17, 29, 49, 38, 27, 45, 17, 40, 68, 16, 17, 41, 50, 26, 20, 28, 36, 23, 27, 39, 46, 25, 24, 47, 60, 44, 47, 29, 25, 58, 36, 39, 53, 33, 35, 48, 41, 39, 34, 16, 64, 50, 45, 53, 16, 37, 59, 51, 50, 30, 59, 20, 15, 39, 65, 40, 25, 36, 53, 40, 57, 42, 48, 66, 26, 51, 25, 41, 75, 54, 34, 52, 15, 56, 41, 49, 42, 26, 26, 33, 64, 46, 45, 14, 33, 60, 26, 59, 58, 53, 27, 51, 15, 41, 10, 33, 22, 31, 48, 21, 51, 27, 18, 37, 49, 51, 37, 68, 21, 35, 69, 42, 29, 41, 34, 64, 15, 28, 35, 38, 50, 50, 34, 62, 59, 27, 53, 23, 43, 48, 33, 15, 55, 40, 54, 37, 34, 31, 26, 50, 28, 44, 22, 59, 43, 40, 47, 34, 61, 34, 44, 42, 54, 57, 50, 46, 37, 21, 26, 39, 61, 33, 37, 45, 28, 44, 20, 50, 24, 40, 36, 44, 44, 44, 22, 73, 49, 18, 16, 39, 61, 31, 48, 20, 27, 59, 31, 45, 43, 32, 46, 29, 46, 16, 28, 35, 45, 42, 32, 29, 69, 35, 43, 25, 56, 53, 31, 34, 21, 60, 30, 59, 41, 42, 59, 49, 37, 30, 28, 61, 17, 52, 23, 33, 34, 36, 19, 45, 46, 27, 25, 33, 38, 50, 24, 19, 34, 51, 35, 38, 33, 36, 34, 25, 34, 33, 39, 20, 56, 30, 26, 27, 42, 65, 42, 55, 38, 38, 43, 45, 43, 9, 51, 58, 34, 39, 64, 42, 20, 47, 26, 26, 22, 47, 46, 41, 49, 19, 46, 73, 41, 32, 19, 57, 65, 22, 17, 26, 26, 46, 66, 47, 61, 70, 38, 42, 56, 34, 36, 52, 34, 59, 66, 69, 58, 29, 48, 21, 48, 50, 28, 42, 30, 55, 42, 39, 69, 50, 76, 55, 54, 40, 58, 39, 54, 31, 39, 50, 32, 49, 45, 61, 39, 38, 45, 49, 52, 43, 27, 19, 59, 35, 23, 55, 34, 32, 61, 22, 33, 51, 23, 17, 52, 62, 59, 54, 48, 24, 27, 22, 58, 28, 29, 7, 33, 60, 50, 56, 10, 11, 42, 35, 56, 53, 18, 37, 24, 70, 28, 35, 35, 13, 23, 46, 19, 29, 52, 49, 55, 45, 28, 47, 37, 40, 42, 67, 28, 37, 16, 27, 43, 41, 40, 54, 60, 38, 45, 65, 21, 33, 55, 34, 44, 29, 45, 34, 65, 60, 10, 44, 28, 21, 53, 54, 48, 41, 34, 41, 32, 42, 18, 31, 22, 45, 54, 44, 49, 22, 37, 41, 59, 32, 35, 37, 38, 66, 49, 53, 30, 31, 18, 49, 14, 56, 40, 27, 18, 16, 16, 31, 66, 46, 41, 21, 54, 51, 51, 42, 43, 31, 36, 32, 17, 35, 30, 29, 38, 47, 32, 13, 57, 45, 35, 60, 38]}, 'test_1': {'capacity': 100, 'num_items': 5000, 'items': [42, 57, 41, 42, 43, 30, 26, 21, 42, 24, 37, 52, 50, 32, 76, 58, 69, 35, 30, 42, 40, 28, 63, 60, 42, 46, 38, 39, 45, 43, 53, 72, 26, 41, 39, 19, 63, 43, 32, 29, 48, 33, 29, 17, 44, 13, 57, 48, 12, 60, 51, 27, 55, 40, 22, 63, 37, 53, 34, 25, 41, 54, 36, 46, 43, 44, 41, 42, 20, 35, 31, 32, 72, 36, 20, 26, 26, 65, 48, 31, 71, 43, 46, 36, 33, 52, 32, 35, 56, 35, 29, 36, 61, 50, 66, 36, 29, 13, 60, 43, 40, 66, 49, 28, 48, 23, 35, 55, 84, 50, 50, 39, 33, 45, 42, 40, 27, 26, 21, 54, 30, 59, 18, 41, 52, 8, 19, 64, 41, 38, 50, 53, 65, 20, 15, 18, 36, 27, 27, 30, 43, 10, 33, 55, 26, 28, 48, 50, 36, 43, 39, 42, 48, 8, 46, 21, 15, 59, 33, 41, 40, 46, 44, 33, 42, 30, 32, 57, 30, 32, 30, 30, 41, 77, 49, 14, 54, 56, 68, 53, 24, 31, 29, 43, 22, 16, 26, 47, 18, 46, 29, 13, 47, 33, 44, 40, 60, 22, 66, 55, 37, 41, 37, 32, 37, 53, 77, 42, 28, 35, 32, 28, 27, 63, 36, 38, 61, 40, 17, 66, 53, 45, 55, 24, 3, 45, 53, 43, 59, 70, 45, 33, 68, 44, 39, 64, 56, 27, 42, 24, 54, 61, 51, 34, 58, 44, 44, 45, 56, 38, 40, 14, 57, 51, 25, 15, 35, 57, 51, 45, 16, 30, 29, 31, 45, 35, 47, 20, 20, 20, 34, 57, 61, 37, 34, 23, 31, 40, 46, 49, 59, 41, 39, 42, 23, 44, 29, 32, 31, 35, 19, 20, 54, 12, 35, 53, 40, 70, 39, 31, 43, 38, 28, 33, 38, 50, 33, 19, 30, 60, 45, 30, 43, 39, 47, 40, 33, 32, 15, 26, 53, 51, 63, 27, 55, 34, 56, 26, 56, 52, 42, 45, 39, 35, 65, 47, 33, 26, 50, 63, 24, 32, 34, 24, 47, 51, 66, 45, 42, 30, 49, 57, 40, 21, 21, 43, 31, 42, 33, 11, 75, 46, 40, 43, 34, 43, 38, 56, 42, 28, 51, 27, 44, 51, 28, 53, 41, 27, 27, 36, 50, 48, 56, 68, 28, 45, 54, 56, 33, 49, 26, 29, 33, 30, 53, 39, 26, 51, 19, 39, 27, 29, 56, 32, 40, 55, 40, 21, 32, 32, 19, 18, 54, 41, 27, 46, 43, 31, 17, 46, 31, 39, 39, 56, 34, 40, 23, 32, 28, 38, 21, 50, 51, 21, 37, 28, 35, 34, 48, 10, 45, 46, 62, 10, 24, 56, 60, 46, 54, 42, 47, 40, 20, 58, 45, 41, 16, 25, 72, 58, 42, 55, 36, 39, 31, 34, 6, 53, 52, 31, 46, 43, 24, 78, 56, 12, 43, 30, 59, 38, 48, 32, 11, 33, 36, 22, 53, 34, 70, 45, 40, 38, 30, 31, 70, 46, 20, 72, 35, 22, 32, 39, 44, 58, 34, 32, 41, 81, 52, 62, 27, 50, 29, 51, 40, 37, 48, 50, 48, 45, 9, 16, 33, 42, 50, 66, 16, 12, 77, 21, 58, 22, 38, 12, 27, 57, 19, 61, 41, 33, 25, 35, 61, 60, 66, 22, 56, 59, 34, 35, 38, 53, 53, 40, 36, 13, 27, 25, 35, 35, 66, 41, 64, 47, 62, 50, 36, 48, 33, 41, 39, 45, 49, 35, 63, 37, 16, 42, 35, 45, 24, 48, 35, 48, 21, 14, 22, 63, 26, 23, 40, 59, 48, 58, 44, 32, 69, 72, 41, 41, 51, 15, 29, 22, 42, 49, 40, 35, 48, 18, 29, 23, 25, 28, 54, 19, 13, 67, 37, 43, 31, 13, 46, 30, 29, 47, 48, 46, 49, 31, 38, 40, 54, 39, 49, 49, 50, 16, 20, 33, 46, 59, 33, 46, 49, 36, 41, 32, 44, 52, 49, 76, 32, 42, 45, 52, 47, 38, 21, 49, 22, 63, 35, 34, 51, 42, 73, 30, 62, 55, 25, 56, 51, 48, 49, 51, 52, 24, 55, 50, 25, 17, 30, 31, 33, 25, 47, 29, 38, 16, 28, 35, 51, 40, 4, 52, 15, 30, 27, 41, 43, 72, 21, 52, 47, 22, 51, 71, 29, 62, 38, 26, 64, 19, 32, 49, 39, 47, 56, 39, 51, 36, 51, 36, 57, 79, 41, 40, 47, 30, 31, 54, 45, 16, 22, 40, 46, 23, 27, 53, 53, 33, 19, 9, 11, 56, 45, 34, 37, 53, 50, 36, 48, 49, 40, 49, 32, 45, 19, 48, 33, 33, 36, 52, 32, 50, 27, 31, 19, 30, 21, 54, 68, 64, 28, 56, 8, 55, 34, 22, 54, 30, 60, 37, 29, 18, 20, 10, 17, 19, 27, 41, 35, 34, 55, 28, 51, 35, 22, 47, 41, 44, 46, 28, 20, 22, 28, 47, 50, 86, 43, 50, 20, 13, 55, 54, 45, 50, 51, 21, 53, 42, 45, 46, 39, 48, 47, 35, 14, 29, 29, 56, 57, 51, 42, 21, 40, 26, 55, 41, 32, 37, 16, 58, 52, 42, 58, 35, 61, 38, 15, 54, 8, 44, 47, 30, 69, 36, 42, 27, 28, 45, 45, 68, 18, 50, 55, 21, 32, 36, 33, 48, 29, 42, 23, 65, 37, 31, 25, 37, 52, 39, 11, 26, 51, 80, 35, 37, 40, 40, 31, 67, 35, 36, 41, 72, 34, 64, 17, 35, 44, 22, 37, 67, 49, 65, 53, 52, 40, 34, 35, 22, 43, 17, 43, 56, 46, 31, 16, 39, 39, 47, 58, 47, 43, 32, 18, 42, 48, 61, 46, 37, 46, 61, 57, 41, 29, 34, 17, 53, 18, 51, 44, 38, 55, 44, 59, 32, 64, 19, 30, 12, 34, 45, 35, 26, 20, 33, 9, 12, 52, 29, 23, 28, 28, 59, 34, 30, 51, 45, 9, 22, 34, 33, 17, 29, 45, 13, 15, 24, 51, 24, 48, 27, 33, 53, 28, 16, 34, 35, 37, 11, 57, 17, 59, 30, 36, 60, 69, 48, 33, 32, 35, 50, 29, 34, 55, 12, 28, 12, 42, 33, 50, 62, 14, 61, 50, 43, 56, 22, 45, 32, 26, 63, 19, 6, 24, 28, 25, 31, 38, 48, 73, 49, 29, 16, 37, 50, 54, 56, 19, 61, 47, 31, 28, 42, 66, 45, 75, 55, 27, 13, 16, 49, 26, 28, 66, 24, 35, 59, 38, 47, 23, 19, 34, 30, 49, 36, 48, 25, 5, 27, 46, 46, 22, 54, 9, 61, 17, 41, 43, 34, 29, 56, 44, 38, 36, 23, 31, 60, 44, 23, 38, 33, 20, 28, 28, 56, 45, 25, 40, 51, 55, 38, 36, 48, 45, 62, 66, 58, 30, 36, 40, 55, 36, 51, 57, 24, 49, 32, 29, 26, 45, 33, 39, 36, 55, 21, 17, 23, 38, 26, 72, 48, 46, 40, 58, 36, 39, 45, 31, 31, 48, 69, 22, 18, 65, 47, 56, 51, 32, 37, 29, 30, 38, 32, 30, 34, 34, 38, 46, 35, 33, 28, 54, 53, 78, 35, 60, 48, 32, 22, 35, 47, 20, 24, 20, 35, 50, 36, 58, 29, 40, 45, 22, 20, 27, 77, 24, 40, 31, 45, 50, 57, 47, 42, 34, 42, 48, 64, 43, 35, 44, 21, 26, 48, 32, 32, 22, 38, 30, 35, 40, 64, 32, 49, 28, 15, 43, 54, 22, 61, 45, 45, 39, 48, 39, 74, 52, 55, 50, 51, 42, 32, 29, 28, 13, 42, 39, 53, 48, 35, 45, 31, 38, 39, 26, 54, 23, 45, 30, 58, 31, 29, 47, 19, 74, 22, 41, 20, 70, 25, 32, 62, 16, 22, 64, 17, 50, 24, 49, 33, 20, 54, 15, 32, 67, 57, 38, 65, 35, 50, 55, 51, 23, 65, 31, 53, 36, 34, 49, 65, 32, 62, 33, 49, 52, 33, 47, 29, 36, 45, 24, 44, 30, 71, 32, 37, 36, 48, 48, 23, 36, 55, 23, 30, 37, 30, 48, 22, 39, 25, 27, 49, 34, 28, 33, 52, 55, 36, 60, 29, 44, 52, 48, 55, 16, 51, 41, 35, 30, 48, 33, 55, 24, 56, 50, 36, 49, 15, 37, 64, 56, 41, 15, 38, 21, 31, 61, 54, 32, 52, 41, 65, 41, 53, 37, 35, 23, 56, 40, 53, 11, 34, 53, 27, 48, 47, 80, 20, 57, 64, 44, 56, 26, 10, 31, 21, 32, 19, 26, 42, 27, 43, 59, 20, 70, 47, 17, 42, 13, 40, 45, 13, 47, 32, 42, 39, 63, 22, 30, 67, 63, 65, 37, 32, 53, 36, 43, 50, 12, 37, 39, 29, 35, 41, 40, 44, 50, 62, 33, 49, 43, 27, 46, 43, 13, 49, 49, 19, 42, 34, 44, 61, 59, 27, 30, 33, 45, 20, 21, 66, 47, 51, 49, 49, 32, 20, 74, 33, 66, 49, 45, 33, 29, 32, 18, 7, 37, 64, 43, 65, 25, 35, 45, 30, 31, 58, 29, 20, 9, 35, 13, 26, 41, 24, 50, 20, 64, 39, 35, 68, 40, 54, 48, 48, 67, 43, 51, 38, 35, 50, 65, 30, 46, 64, 27, 7, 46, 68, 53, 37, 66, 37, 3, 65, 50, 38, 31, 32, 29, 64, 34, 21, 32, 47, 27, 38, 31, 50, 54, 55, 34, 30, 24, 37, 42, 26, 24, 30, 46, 54, 29, 34, 39, 36, 16, 57, 50, 25, 21, 37, 43, 39, 40, 49, 44, 46, 13, 28, 41, 62, 32, 36, 30, 56, 37, 38, 72, 6, 47, 39, 37, 74, 36, 53, 31, 34, 28, 27, 47, 45, 54, 23, 50, 28, 49, 43, 45, 65, 21, 17, 35, 21, 16, 20, 47, 17, 45, 29, 24, 61, 50, 28, 26, 46, 18, 40, 27, 42, 46, 48, 24, 36, 23, 61, 55, 62, 56, 28, 36, 73, 61, 48, 41, 6, 18, 46, 48, 38, 48, 68, 26, 41, 28, 54, 36, 58, 27, 49, 40, 16, 44, 69, 36, 23, 35, 45, 55, 58, 39, 24, 43, 32, 45, 46, 50, 30, 44, 61, 57, 37, 45, 72, 33, 30, 50, 28, 23, 26, 36, 51, 36, 44, 37, 27, 38, 29, 47, 55, 27, 31, 17, 36, 53, 74, 44, 47, 36, 37, 35, 54, 26, 52, 34, 31, 49, 61, 27, 31, 29, 21, 47, 69, 49, 27, 49, 44, 41, 60, 57, 48, 48, 65, 50, 41, 53, 26, 47, 38, 22, 18, 44, 23, 52, 48, 45, 41, 18, 38, 42, 21, 45, 72, 46, 35, 49, 54, 54, 20, 43, 42, 63, 45, 38, 14, 22, 55, 51, 37, 12, 52, 38, 20, 43, 45, 78, 24, 21, 23, 20, 29, 24, 37, 46, 38, 22, 38, 33, 40, 31, 30, 25, 50, 14, 47, 29, 20, 56, 20, 42, 35, 44, 49, 68, 34, 15, 46, 40, 31, 57, 28, 35, 37, 16, 46, 12, 67, 39, 21, 23, 41, 59, 50, 13, 36, 73, 41, 29, 44, 45, 47, 59, 72, 51, 61, 23, 22, 27, 55, 37, 12, 57, 37, 67, 36, 17, 50, 29, 39, 41, 39, 32, 46, 47, 41, 42, 67, 45, 28, 37, 37, 59, 55, 51, 35, 18, 48, 46, 82, 35, 40, 62, 46, 20, 11, 50, 40, 11, 32, 35, 26, 63, 36, 35, 45, 61, 43, 50, 19, 17, 54, 55, 51, 35, 52, 38, 62, 37, 53, 40, 56, 25, 14, 36, 48, 56, 36, 19, 31, 45, 28, 52, 36, 40, 82, 33, 42, 50, 33, 19, 28, 13, 67, 63, 28, 44, 21, 85, 21, 34, 23, 60, 37, 53, 33, 49, 49, 56, 75, 37, 52, 37, 58, 42, 39, 31, 24, 54, 37, 29, 60, 58, 42, 27, 31, 53, 42, 43, 54, 47, 19, 26, 19, 45, 24, 30, 41, 26, 31, 46, 7, 48, 40, 47, 34, 30, 32, 33, 61, 48, 34, 48, 38, 51, 33, 22, 40, 49, 36, 46, 54, 64, 61, 50, 47, 44, 65, 65, 47, 31, 28, 30, 45, 43, 36, 51, 44, 66, 49, 19, 23, 45, 35, 17, 18, 37, 52, 27, 24, 52, 34, 51, 31, 63, 38, 36, 38, 30, 26, 9, 46, 54, 26, 29, 49, 23, 46, 40, 19, 23, 46, 29, 44, 46, 20, 15, 25, 30, 63, 60, 38, 30, 38, 35, 33, 35, 39, 51, 22, 34, 26, 26, 17, 34, 9, 21, 17, 23, 41, 18, 15, 44, 41, 30, 57, 43, 36, 40, 44, 32, 35, 44, 16, 41, 27, 46, 58, 47, 47, 25, 32, 42, 37, 22, 29, 21, 46, 33, 40, 77, 34, 18, 37, 33, 51, 65, 36, 38, 59, 48, 40, 22, 41, 17, 44, 39, 44, 22, 28, 41, 41, 62, 52, 41, 45, 54, 62, 39, 59, 48, 19, 54, 40, 45, 30, 33, 49, 26, 51, 42, 54, 48, 38, 33, 41, 27, 49, 51, 80, 29, 43, 56, 17, 29, 30, 32, 34, 41, 19, 38, 50, 15, 34, 54, 12, 24, 58, 31, 69, 26, 49, 52, 37, 55, 32, 46, 47, 54, 27, 33, 30, 36, 38, 28, 69, 43, 50, 45, 58, 59, 21, 41, 16, 41, 33, 16, 57, 28, 16, 13, 42, 19, 45, 52, 37, 23, 60, 27, 77, 32, 50, 49, 59, 44, 27, 46, 28, 53, 61, 15, 21, 43, 45, 42, 25, 64, 18, 64, 37, 35, 71, 51, 39, 23, 13, 3, 21, 71, 27, 37, 37, 71, 22, 58, 55, 46, 52, 69, 44, 30, 60, 14, 31, 32, 54, 48, 59, 30, 2, 21, 28, 22, 39, 7, 42, 39, 52, 57, 14, 13, 46, 37, 40, 33, 24, 60, 28, 54, 33, 49, 22, 23, 33, 23, 43, 53, 47, 40, 22, 18, 39, 41, 29, 62, 28, 49, 27, 45, 38, 30, 75, 25, 31, 45, 54, 17, 33, 18, 37, 38, 63, 46, 44, 45, 69, 42, 32, 46, 49, 36, 24, 45, 50, 18, 45, 44, 49, 23, 30, 57, 10, 87, 38, 66, 50, 44, 33, 17, 60, 58, 53, 32, 38, 48, 20, 31, 56, 43, 52, 35, 48, 37, 21, 24, 44, 42, 58, 28, 54, 56, 48, 28, 46, 73, 38, 62, 46, 44, 64, 40, 22, 54, 38, 41, 47, 47, 58, 19, 49, 28, 52, 41, 23, 31, 56, 32, 38, 53, 15, 21, 73, 58, 21, 34, 24, 22, 37, 39, 57, 16, 58, 42, 50, 71, 24, 41, 51, 33, 59, 18, 12, 24, 39, 33, 15, 73, 66, 47, 20, 27, 29, 31, 7, 44, 19, 31, 45, 34, 39, 38, 53, 67, 49, 52, 37, 40, 54, 36, 40, 31, 53, 27, 42, 40, 43, 29, 30, 22, 43, 78, 38, 30, 30, 24, 42, 63, 52, 6, 13, 12, 44, 27, 17, 50, 19, 36, 46, 45, 59, 61, 58, 59, 37, 22, 39, 44, 14, 58, 71, 74, 51, 41, 41, 49, 39, 45, 28, 33, 23, 36, 28, 43, 13, 28, 48, 44, 40, 59, 50, 29, 41, 72, 22, 16, 44, 44, 47, 39, 45, 58, 29, 68, 47, 59, 13, 51, 14, 45, 39, 49, 57, 47, 58, 70, 53, 28, 37, 52, 53, 42, 42, 45, 54, 56, 82, 38, 55, 30, 33, 53, 44, 64, 33, 38, 37, 19, 38, 37, 53, 46, 25, 46, 13, 29, 50, 61, 49, 56, 53, 61, 30, 34, 47, 54, 22, 13, 50, 42, 30, 16, 16, 38, 40, 18, 24, 16, 44, 30, 52, 44, 29, 50, 34, 64, 8, 42, 41, 55, 55, 57, 32, 23, 16, 41, 40, 37, 27, 10, 52, 69, 24, 40, 55, 35, 47, 30, 40, 46, 40, 10, 24, 30, 36, 73, 26, 28, 29, 60, 64, 54, 52, 53, 33, 33, 40, 23, 51, 66, 62, 55, 37, 30, 24, 40, 71, 17, 50, 31, 23, 38, 35, 46, 32, 50, 42, 47, 48, 36, 47, 29, 22, 41, 60, 66, 57, 18, 20, 61, 38, 17, 40, 31, 42, 47, 44, 60, 9, 33, 37, 34, 62, 49, 27, 44, 22, 25, 52, 44, 46, 18, 42, 46, 16, 31, 21, 35, 31, 67, 46, 32, 38, 40, 42, 39, 23, 20, 28, 21, 34, 22, 33, 60, 49, 52, 25, 46, 59, 48, 55, 45, 38, 40, 28, 43, 7, 39, 80, 34, 15, 32, 38, 68, 42, 52, 61, 70, 28, 54, 50, 52, 45, 35, 39, 27, 29, 65, 35, 24, 52, 8, 32, 62, 29, 51, 48, 37, 54, 29, 45, 33, 31, 69, 33, 14, 35, 39, 30, 29, 64, 64, 12, 24, 16, 40, 53, 49, 39, 52, 40, 29, 52, 60, 50, 51, 44, 18, 65, 58, 28, 51, 61, 56, 53, 21, 34, 62, 63, 59, 35, 44, 46, 56, 48, 32, 52, 25, 34, 33, 40, 16, 17, 42, 46, 51, 40, 43, 31, 68, 24, 49, 37, 31, 38, 24, 29, 65, 12, 53, 63, 32, 7, 41, 32, 26, 35, 42, 25, 29, 28, 46, 56, 34, 50, 9, 53, 29, 14, 48, 61, 33, 46, 40, 6, 65, 26, 65, 30, 43, 22, 27, 48, 60, 32, 21, 63, 30, 55, 54, 29, 65, 23, 20, 41, 52, 22, 28, 48, 33, 22, 55, 43, 64, 73, 45, 49, 53, 17, 71, 31, 56, 44, 35, 39, 32, 53, 38, 32, 40, 49, 58, 25, 46, 11, 30, 35, 43, 40, 40, 38, 27, 41, 31, 34, 58, 33, 21, 54, 66, 53, 26, 62, 27, 13, 59, 9, 48, 20, 34, 29, 27, 50, 69, 36, 28, 18, 22, 34, 51, 28, 66, 30, 55, 53, 50, 43, 60, 28, 31, 24, 34, 47, 26, 36, 16, 38, 47, 51, 65, 36, 34, 14, 40, 17, 55, 23, 33, 44, 27, 62, 59, 31, 6, 43, 19, 63, 21, 32, 61, 26, 39, 12, 35, 33, 48, 7, 41, 58, 47, 15, 45, 51, 59, 43, 56, 33, 26, 40, 50, 57, 31, 46, 27, 62, 39, 44, 45, 36, 46, 37, 44, 43, 35, 45, 53, 10, 7, 45, 33, 23, 29, 30, 35, 66, 34, 66, 37, 54, 30, 23, 48, 62, 60, 45, 68, 42, 50, 47, 51, 22, 43, 52, 40, 46, 46, 14, 7, 35, 33, 18, 52, 56, 18, 63, 43, 18, 49, 61, 58, 32, 33, 15, 12, 38, 47, 15, 39, 38, 44, 52, 47, 44, 58, 23, 23, 47, 38, 40, 66, 28, 19, 22, 25, 21, 38, 39, 57, 45, 14, 38, 23, 62, 25, 69, 30, 52, 29, 20, 51, 40, 30, 42, 36, 25, 48, 47, 54, 8, 23, 59, 32, 78, 50, 27, 42, 28, 33, 40, 29, 32, 21, 39, 59, 69, 42, 40, 16, 51, 27, 45, 38, 42, 66, 38, 26, 28, 44, 51, 54, 65, 39, 70, 29, 42, 48, 41, 51, 48, 51, 23, 58, 33, 43, 35, 50, 54, 38, 40, 43, 74, 29, 56, 55, 40, 20, 47, 43, 23, 45, 12, 50, 42, 56, 22, 32, 10, 26, 47, 54, 21, 8, 37, 34, 32, 42, 41, 15, 28, 58, 19, 35, 34, 47, 8, 30, 68, 21, 41, 25, 18, 60, 60, 48, 59, 56, 32, 32, 86, 17, 64, 51, 60, 19, 47, 41, 39, 23, 23, 62, 36, 41, 35, 49, 27, 28, 60, 11, 55, 35, 38, 14, 62, 28, 12, 55, 11, 34, 27, 46, 55, 31, 51, 24, 66, 49, 51, 39, 55, 21, 43, 40, 36, 39, 65, 38, 29, 46, 33, 27, 27, 26, 19, 25, 29, 30, 23, 50, 44, 19, 35, 34, 67, 51, 38, 53, 22, 42, 21, 61, 43, 28, 44, 12, 27, 36, 61, 40, 61, 39, 54, 30, 25, 44, 17, 54, 55, 29, 34, 31, 48, 39, 41, 61, 33, 62, 46, 36, 9, 45, 32, 54, 59, 48, 51, 37, 35, 33, 36, 53, 51, 46, 49, 18, 59, 27, 42, 50, 26, 52, 35, 26, 37, 47, 37, 41, 48, 54, 35, 40, 35, 24, 34, 33, 43, 44, 17, 45, 26, 56, 29, 43, 45, 14, 16, 42, 54, 31, 49, 59, 68, 16, 20, 63, 52, 47, 51, 64, 39, 49, 41, 65, 38, 30, 34, 9, 26, 32, 27, 20, 39, 71, 49, 16, 39, 52, 49, 64, 37, 33, 26, 46, 19, 51, 36, 51, 20, 49, 63, 67, 68, 48, 14, 51, 54, 43, 36, 41, 18, 39, 44, 61, 36, 40, 29, 35, 32, 63, 41, 21, 35, 43, 28, 53, 55, 67, 57, 35, 54, 57, 52, 33, 63, 25, 34, 57, 77, 45, 57, 30, 51, 44, 53, 42, 51, 33, 34, 63, 41, 45, 35, 40, 48, 25, 53, 48, 50, 37, 37, 55, 52, 30, 44, 35, 41, 51, 45, 42, 35, 35, 23, 34, 28, 37, 38, 63, 61, 52, 67, 52, 41, 63, 39, 33, 56, 39, 50, 63, 42, 29, 41, 38, 59, 10, 52, 56, 53, 39, 41, 43, 68, 49, 33, 43, 41, 40, 38, 20, 42, 48, 30, 65, 22, 49, 40, 34, 62, 30, 32, 28, 40, 44, 40, 2, 68, 35, 31, 48, 44, 13, 79, 27, 22, 51, 40, 28, 31, 57, 54, 47, 20, 61, 20, 26, 53, 25, 48, 27, 23, 40, 54, 24, 57, 22, 73, 25, 44, 42, 40, 52, 18, 17, 34, 40, 30, 35, 30, 46, 35, 46, 15, 18, 19, 28, 46, 81, 53, 42, 48, 36, 61, 25, 40, 25, 34, 66, 34, 29, 48, 39, 53, 40, 31, 28, 57, 45, 33, 12, 28, 21, 53, 47, 50, 38, 54, 44, 26, 27, 10, 46, 33, 46, 53, 50, 45, 31, 34, 43, 40, 43, 55, 39, 45, 33, 51, 25, 62, 31, 25, 28, 34, 52, 24, 23, 36, 87, 32, 54, 42, 26, 52, 46, 58, 39, 63, 51, 22, 31, 35, 42, 42, 49, 36, 24, 63, 69, 27, 49, 50, 39, 22, 28, 40, 31, 34, 42, 36, 43, 51, 45, 20, 28, 63, 54, 19, 54, 49, 25, 49, 21, 47, 36, 42, 38, 33, 24, 19, 31, 35, 39, 49, 9, 44, 27, 16, 47, 33, 45, 50, 51, 37, 36, 32, 64, 41, 47, 53, 59, 29, 69, 28, 65, 42, 44, 31, 47, 37, 37, 25, 62, 39, 28, 51, 55, 62, 39, 39, 38, 54, 45, 18, 54, 44, 26, 34, 52, 32, 28, 58, 29, 38, 39, 55, 46, 26, 60, 23, 50, 34, 40, 58, 31, 46, 36, 31, 54, 46, 54, 27, 77, 62, 55, 36, 20, 53, 54, 37, 50, 59, 34, 37, 44, 33, 27, 62, 29, 31, 57, 44, 43, 46, 40, 22, 45, 33, 31, 39, 51, 51, 51, 48, 61, 61, 22, 48, 47, 49, 35, 33, 15, 10, 34, 33, 52, 81, 50, 59, 57, 41, 21, 45, 64, 56, 30, 39, 37, 47, 42, 46, 23, 59, 25, 23, 48, 58, 16, 39, 20, 46, 52, 23, 55, 43, 40, 36, 28, 44, 28, 21, 60, 39, 27, 55, 39, 38, 46, 27, 40, 60, 40, 38, 22, 48, 41, 24, 20, 49, 36, 27, 17, 67, 36, 66, 42, 48, 49, 89, 31, 38, 40, 10, 24, 63, 35, 67, 43, 54, 15, 31, 41, 60, 53, 31, 34, 15, 35, 33, 19, 38, 22, 32, 32, 33, 59, 54, 18, 40, 18, 37, 41, 30, 36, 49, 56, 43, 52, 33, 62, 25, 28, 36, 16, 50, 19, 47, 69, 16, 32, 41, 45, 45, 42, 61, 61, 29, 25, 40, 39, 49, 52, 45, 37, 51, 32, 32, 55, 82, 42, 17, 30, 53, 34, 60, 38, 44, 49, 31, 48, 40, 24, 35, 14, 37, 23, 56, 41, 28, 22, 17, 47, 28, 47, 39, 32, 49, 26, 53, 31, 24, 32, 45, 65, 25, 26, 43, 34, 51, 29, 27, 53, 77, 24, 48, 38, 39, 15, 75, 18, 56, 45, 71, 32, 41, 46, 19, 51, 50, 44, 59, 46, 41, 16, 23, 75, 55, 31, 35, 75, 44, 50, 57, 40, 59, 63, 29, 52, 32, 45, 25, 33, 39, 46, 63, 23, 37, 47, 23, 40, 38, 16, 23, 38, 23, 32, 38, 56, 26, 51, 30, 26, 15, 24, 49, 49, 34, 33, 44, 32, 10, 14, 30, 37, 34, 36, 74, 38, 29, 33, 23, 45, 34, 40, 25, 39, 18, 50, 71, 40, 27, 22, 35, 11, 24, 52, 38, 24, 51, 27, 36, 52, 16, 40, 44, 55, 29, 6, 43, 41, 32, 38, 53, 43, 36, 25, 54, 34, 50, 66, 46, 67, 19, 47, 34, 27, 38, 34, 44, 28, 31, 51, 34, 46, 38, 44, 61, 35, 53, 17, 25, 35, 48, 52, 34, 26, 17, 37, 37, 22, 19, 60, 48, 68, 75, 44, 26, 37, 55, 31, 31, 54, 51, 64, 67, 20, 62, 41, 45, 25, 35, 25, 15, 47, 48, 17, 36, 40, 43, 48, 36, 40, 28, 54, 52, 19, 40, 47, 26, 42, 48, 22, 51, 22, 46, 59, 51, 24, 50, 47, 17, 52, 23, 45, 19, 63, 30, 47, 46, 46, 22, 41, 62, 26, 14, 31, 48, 50, 68, 38, 33, 42, 44, 44, 19, 19, 11, 13, 33, 48, 54, 46, 48, 24, 16, 58, 21, 18, 38, 44, 26, 57, 41, 55, 53, 37, 35, 55, 52, 32, 40, 54, 41, 60, 46, 48, 34, 17, 45, 41, 37, 39, 22, 26, 16, 44, 49, 65, 15, 42, 37, 22, 26, 47, 37, 19, 48, 69, 43, 52, 43, 20, 46, 35, 25, 54, 26, 34, 43, 41, 44, 47, 8, 77, 30, 17, 46, 9, 58, 43, 41, 65, 50, 49, 38, 61, 44, 54, 22, 33, 31, 30, 19, 49, 56, 18, 68, 27, 47, 43, 13, 53, 41, 28, 54, 52, 27, 36, 29, 34, 46, 45, 39, 84, 29, 30, 28, 43, 55, 30, 13, 24, 41, 29, 30, 21, 21, 40, 60, 40, 33, 68, 25, 25, 53, 20, 56, 51, 26, 20, 47, 34, 64, 21, 33, 25, 62, 36, 48, 46, 43, 42, 66, 77, 29, 39, 34, 35, 16, 30, 10, 33, 57, 41, 36, 23, 50, 14, 32, 17, 31, 27, 62, 28, 35, 30, 60, 45, 22, 33, 26, 70, 49, 28, 35, 32, 39, 22, 59, 44, 19, 37, 28, 45, 13, 9, 41, 38, 21, 44, 12, 64, 44, 48, 43, 58, 26, 40, 26, 54, 27, 30, 31, 41, 37, 33, 31, 47, 48, 42, 20, 46, 23, 36, 59, 33, 38, 20, 65, 51, 33, 46, 33, 32, 39, 41, 31, 63, 67, 44, 57, 17, 76, 32, 41, 42, 41, 33, 16, 71, 33, 32, 37, 29, 59, 70, 38, 39, 61, 26, 49, 70, 61, 42, 60, 46, 21, 46, 32, 47, 37, 29, 41, 43, 50, 34, 35, 23, 35, 59, 40, 38, 45, 30, 50, 37, 54, 76, 24, 40, 50, 19, 67, 35, 55, 75, 49, 28, 12, 55, 45, 78, 43, 55, 56, 35, 41, 42, 27, 58, 25, 52, 45, 32, 29, 15, 43, 25, 8, 31, 32, 16, 32, 38, 44, 23, 21, 37, 48, 37, 40, 22, 14, 29, 55, 26, 19, 46, 26, 22, 30, 56, 23, 8, 48, 33, 23, 63, 71, 53, 52, 24, 56, 49, 20, 40, 53, 36, 61, 56, 15, 31, 44, 35, 60, 46, 50, 54, 36, 55, 22, 25, 40, 40, 49, 46, 53, 19, 51, 51, 27, 51, 53, 22, 25, 21, 25, 18, 42, 55, 43, 39, 27, 42, 6, 38, 42, 62, 10, 39, 15, 32, 25, 48, 24, 41, 39, 75, 41, 22, 52, 11, 29, 54, 42, 30, 16, 21, 22, 42, 21, 64, 16, 18, 57, 47, 42, 3, 36, 13, 29, 52, 34, 28, 39, 74, 43, 50, 43, 42, 68, 22, 49, 35, 51, 47, 29, 36, 35, 27, 53, 13, 84, 29, 18, 33, 54, 54, 67, 45, 53, 41, 54, 18, 49, 39, 36, 46, 17, 31, 23, 33, 50, 39, 33, 43, 19, 35, 29, 41, 72, 52, 53, 45, 64, 26, 26, 45, 38, 31, 21, 31, 16, 15, 38, 32, 55, 26, 20, 37, 50, 20, 23, 50, 58, 82, 38, 54, 14, 47, 13, 21, 61, 38, 38, 14, 42, 55, 42, 45, 51, 58, 33, 37, 44, 44, 37, 10, 49, 63, 60, 35, 27, 47, 71, 60, 25, 46, 51, 29, 49, 51, 36, 17, 32, 32, 49, 24, 22, 35, 28, 87, 29, 34, 30, 23, 38, 31, 28, 33, 30, 40, 11, 59, 37, 69, 37, 53, 29, 55, 43, 46, 40, 21, 69, 44, 19, 41, 48, 33, 30, 24, 51, 37, 22, 22, 32, 54, 35, 47, 39, 9, 61, 53, 26, 60, 34, 48, 55, 32, 21, 27, 36, 35, 33, 34, 15, 38, 38, 41, 54, 50, 45, 26, 26, 38, 36, 29, 43, 43, 65, 46, 18, 53, 32, 14, 46, 31, 43, 13, 34, 33, 43, 68, 55, 18, 30, 52, 14, 31, 24, 9, 56, 24, 64, 65, 61, 38, 46, 58, 50, 49, 40, 56, 62, 47, 58, 50, 21, 17, 52, 22, 46, 51, 32, 55, 54, 50, 43, 36, 66, 63, 17, 61, 43, 40, 19, 45, 44, 42, 11, 46, 35, 23, 30, 29, 54, 26, 44, 16, 43, 26, 60, 32, 21, 11, 28, 37, 41, 46, 29, 60, 36, 46, 38, 59, 49, 31, 13, 28, 44, 50, 36, 34, 46, 38, 45, 54, 54, 37, 38, 30, 26, 47, 56, 52, 35, 40, 32, 34, 37, 44, 58, 43, 46, 83, 44, 32, 24, 39, 47, 16, 49, 11, 37, 52, 20, 43, 25, 46, 14, 44, 21, 45, 62, 15, 36, 26, 29, 47, 58, 42, 38, 40, 39, 26, 25, 21, 44, 28, 55, 57, 43, 34, 49, 19, 50, 34, 21, 31, 50, 35, 34, 51, 41, 69, 66, 21, 44, 26, 22, 47, 66, 43, 43, 65, 28, 30, 30, 25, 12, 31, 55, 28, 39, 33, 41, 33, 46, 9, 40, 65, 41, 27, 47, 50, 12, 19, 50, 52, 33, 49, 38, 39, 42, 67, 55, 36, 47, 23, 54, 34, 32]}, 'test_2': {'capacity': 100, 'num_items': 5000, 'items': [20, 47, 39, 29, 7, 45, 45, 18, 39, 48, 15, 25, 33, 40, 52, 32, 33, 30, 11, 57, 15, 44, 22, 23, 83, 19, 34, 17, 14, 34, 50, 36, 52, 62, 48, 68, 40, 33, 27, 18, 25, 37, 39, 46, 35, 50, 60, 66, 52, 32, 31, 25, 62, 38, 54, 31, 58, 34, 20, 42, 57, 19, 21, 30, 21, 29, 20, 47, 43, 31, 34, 70, 19, 27, 17, 61, 53, 20, 69, 37, 32, 40, 49, 47, 26, 55, 52, 62, 41, 53, 17, 16, 42, 43, 49, 41, 41, 38, 25, 41, 42, 28, 14, 40, 50, 47, 16, 26, 38, 46, 35, 39, 77, 14, 55, 51, 43, 41, 23, 27, 60, 60, 38, 14, 31, 54, 23, 44, 44, 32, 32, 27, 24, 40, 51, 8, 46, 29, 10, 48, 65, 31, 55, 13, 23, 50, 28, 13, 38, 60, 27, 32, 22, 25, 45, 54, 38, 35, 23, 60, 77, 77, 24, 27, 28, 45, 17, 54, 45, 55, 42, 32, 42, 67, 55, 33, 57, 41, 35, 16, 35, 36, 45, 23, 24, 34, 35, 37, 48, 57, 57, 46, 47, 51, 59, 60, 42, 31, 63, 40, 31, 37, 11, 20, 49, 51, 33, 49, 53, 31, 51, 44, 39, 30, 41, 17, 43, 51, 33, 17, 39, 42, 38, 52, 55, 46, 55, 45, 58, 43, 59, 40, 42, 5, 45, 31, 28, 36, 52, 53, 48, 47, 9, 38, 45, 27, 34, 38, 47, 51, 34, 44, 40, 14, 67, 56, 30, 25, 42, 37, 21, 31, 69, 51, 46, 45, 55, 26, 58, 45, 50, 58, 44, 66, 27, 23, 28, 50, 39, 74, 30, 12, 24, 18, 27, 40, 55, 59, 58, 37, 29, 17, 17, 37, 21, 16, 41, 17, 39, 33, 42, 30, 60, 31, 32, 23, 32, 28, 17, 60, 24, 36, 29, 25, 81, 43, 44, 51, 51, 46, 28, 32, 36, 57, 39, 32, 31, 46, 35, 25, 70, 46, 50, 53, 50, 35, 49, 30, 33, 64, 41, 25, 29, 47, 26, 61, 54, 64, 29, 35, 35, 58, 47, 26, 58, 8, 66, 41, 64, 52, 22, 34, 38, 17, 14, 44, 33, 24, 36, 56, 49, 29, 35, 23, 15, 49, 79, 42, 36, 18, 50, 32, 27, 44, 36, 50, 51, 24, 83, 48, 35, 33, 37, 14, 32, 33, 34, 38, 40, 63, 31, 41, 51, 34, 71, 56, 37, 46, 52, 62, 36, 35, 57, 43, 26, 36, 43, 53, 17, 66, 39, 23, 42, 39, 17, 53, 57, 32, 44, 32, 44, 30, 53, 32, 41, 22, 38, 39, 15, 22, 45, 46, 59, 35, 31, 14, 37, 38, 24, 33, 53, 29, 39, 37, 61, 36, 47, 37, 29, 25, 47, 42, 31, 41, 59, 55, 28, 44, 49, 50, 33, 41, 51, 43, 32, 58, 55, 38, 49, 38, 36, 40, 54, 72, 53, 51, 42, 47, 49, 48, 57, 52, 33, 27, 33, 28, 41, 22, 48, 25, 50, 23, 41, 36, 54, 55, 25, 53, 26, 8, 47, 44, 48, 26, 8, 50, 39, 44, 68, 44, 70, 50, 44, 52, 39, 64, 41, 64, 52, 38, 16, 20, 11, 41, 25, 29, 35, 37, 17, 21, 46, 40, 32, 25, 14, 57, 29, 31, 20, 32, 48, 70, 48, 20, 61, 57, 25, 59, 35, 80, 27, 26, 54, 45, 54, 50, 46, 23, 48, 31, 40, 27, 43, 24, 48, 61, 36, 41, 41, 31, 42, 55, 49, 48, 37, 20, 35, 45, 37, 11, 32, 54, 50, 4, 24, 61, 48, 63, 38, 43, 38, 27, 20, 52, 22, 11, 38, 53, 27, 43, 26, 40, 47, 38, 42, 56, 52, 72, 53, 40, 25, 50, 43, 49, 32, 55, 25, 51, 37, 41, 56, 47, 37, 57, 29, 27, 60, 34, 42, 61, 46, 31, 38, 54, 48, 34, 55, 59, 38, 43, 22, 27, 28, 29, 30, 53, 60, 16, 55, 13, 39, 29, 28, 44, 42, 53, 60, 33, 48, 48, 44, 40, 57, 50, 59, 28, 31, 65, 23, 27, 44, 46, 57, 36, 60, 23, 23, 58, 51, 47, 15, 57, 50, 33, 14, 42, 44, 19, 24, 42, 40, 51, 37, 33, 50, 39, 38, 28, 31, 49, 55, 68, 42, 81, 21, 38, 55, 49, 39, 31, 36, 59, 62, 62, 79, 36, 55, 57, 23, 24, 32, 18, 53, 34, 70, 32, 38, 40, 43, 41, 35, 30, 53, 24, 47, 38, 36, 30, 52, 28, 67, 58, 23, 29, 33, 21, 54, 42, 44, 41, 33, 52, 35, 42, 39, 44, 50, 34, 53, 29, 50, 26, 8, 41, 39, 25, 48, 34, 45, 30, 35, 38, 57, 65, 34, 33, 47, 28, 42, 62, 42, 12, 31, 51, 13, 51, 47, 28, 76, 54, 34, 66, 18, 51, 32, 27, 48, 46, 15, 36, 43, 58, 35, 32, 41, 43, 16, 52, 22, 70, 19, 34, 25, 45, 27, 41, 33, 43, 47, 43, 62, 29, 62, 56, 33, 23, 72, 66, 44, 28, 29, 16, 20, 55, 53, 48, 59, 44, 44, 39, 14, 42, 40, 47, 67, 28, 51, 19, 44, 42, 41, 50, 12, 47, 37, 38, 11, 31, 51, 25, 29, 5, 22, 32, 51, 44, 56, 61, 43, 16, 50, 38, 20, 62, 70, 31, 37, 30, 69, 46, 13, 19, 45, 20, 10, 42, 34, 64, 56, 10, 35, 41, 32, 34, 48, 61, 55, 37, 49, 40, 26, 42, 35, 44, 41, 62, 29, 34, 34, 41, 54, 55, 35, 34, 37, 30, 29, 36, 62, 35, 38, 45, 31, 35, 37, 43, 38, 48, 45, 43, 28, 50, 49, 42, 64, 29, 75, 47, 60, 30, 55, 56, 62, 48, 35, 36, 22, 43, 56, 30, 37, 41, 21, 31, 60, 56, 15, 38, 32, 53, 25, 26, 36, 65, 40, 30, 42, 54, 47, 10, 11, 36, 61, 31, 53, 33, 21, 58, 42, 39, 43, 83, 44, 26, 25, 52, 10, 30, 29, 45, 30, 56, 39, 12, 38, 56, 33, 29, 31, 42, 36, 25, 24, 44, 54, 43, 48, 29, 38, 57, 50, 21, 67, 42, 28, 38, 22, 68, 11, 38, 15, 28, 58, 47, 24, 43, 50, 27, 17, 38, 20, 39, 53, 34, 61, 37, 57, 30, 20, 33, 65, 43, 44, 65, 38, 38, 15, 69, 49, 40, 30, 41, 14, 45, 43, 27, 56, 30, 45, 53, 39, 72, 32, 35, 15, 48, 18, 66, 54, 58, 44, 40, 40, 48, 25, 33, 62, 38, 43, 38, 20, 21, 29, 45, 35, 41, 61, 48, 25, 42, 36, 25, 34, 51, 39, 46, 53, 68, 21, 26, 18, 49, 49, 12, 29, 29, 46, 63, 38, 32, 49, 67, 28, 39, 19, 42, 55, 44, 44, 29, 26, 29, 33, 24, 22, 22, 57, 55, 29, 19, 34, 59, 43, 45, 37, 58, 80, 28, 76, 39, 51, 20, 32, 55, 34, 43, 65, 14, 60, 41, 33, 30, 35, 38, 51, 37, 49, 33, 43, 34, 21, 91, 9, 67, 41, 52, 24, 45, 35, 38, 35, 33, 37, 52, 42, 37, 45, 24, 44, 38, 32, 47, 38, 47, 65, 73, 31, 47, 46, 29, 70, 35, 36, 19, 34, 59, 46, 23, 31, 31, 21, 33, 32, 32, 43, 43, 23, 66, 52, 20, 35, 51, 47, 23, 58, 40, 44, 43, 12, 75, 41, 31, 35, 30, 48, 34, 28, 47, 43, 53, 37, 57, 36, 37, 45, 41, 60, 34, 33, 41, 17, 26, 67, 63, 46, 69, 29, 46, 27, 51, 38, 39, 47, 33, 31, 58, 38, 32, 53, 39, 41, 44, 20, 15, 23, 52, 44, 46, 49, 40, 13, 46, 25, 52, 48, 44, 29, 70, 42, 41, 19, 36, 54, 28, 48, 42, 34, 64, 13, 22, 46, 60, 58, 65, 52, 46, 38, 56, 36, 52, 18, 41, 64, 59, 41, 47, 20, 64, 15, 33, 72, 45, 36, 51, 47, 39, 38, 30, 58, 78, 56, 47, 38, 53, 36, 21, 62, 57, 37, 46, 54, 14, 36, 58, 67, 42, 41, 37, 31, 30, 55, 59, 46, 42, 31, 42, 22, 24, 62, 36, 52, 44, 54, 30, 24, 61, 19, 49, 63, 52, 57, 42, 9, 66, 17, 54, 23, 40, 27, 59, 53, 45, 48, 42, 22, 22, 42, 51, 47, 30, 40, 26, 34, 50, 47, 33, 37, 27, 31, 45, 61, 34, 40, 36, 29, 59, 34, 56, 38, 24, 32, 51, 47, 26, 22, 69, 25, 58, 25, 57, 11, 45, 15, 54, 34, 52, 16, 47, 29, 54, 18, 29, 32, 66, 43, 51, 37, 59, 46, 35, 19, 44, 43, 35, 18, 36, 59, 36, 33, 42, 42, 48, 35, 36, 5, 19, 35, 39, 63, 25, 44, 42, 41, 61, 52, 37, 42, 37, 48, 51, 65, 41, 30, 29, 25, 44, 48, 74, 19, 22, 40, 28, 45, 35, 44, 35, 46, 27, 41, 75, 42, 19, 27, 39, 50, 19, 49, 32, 38, 71, 50, 24, 45, 31, 33, 23, 45, 32, 30, 60, 33, 25, 25, 34, 14, 46, 37, 38, 30, 34, 31, 49, 62, 42, 33, 39, 49, 23, 65, 27, 29, 81, 59, 54, 43, 31, 56, 23, 59, 65, 44, 50, 59, 45, 32, 41, 29, 11, 14, 25, 37, 22, 37, 44, 62, 44, 28, 53, 9, 49, 44, 34, 49, 67, 51, 37, 26, 45, 28, 24, 57, 31, 54, 16, 36, 32, 22, 28, 19, 24, 39, 69, 46, 22, 39, 58, 45, 41, 23, 26, 60, 35, 50, 43, 35, 57, 32, 19, 45, 10, 42, 36, 15, 78, 40, 57, 21, 33, 56, 51, 15, 67, 26, 25, 64, 38, 36, 39, 43, 30, 35, 34, 44, 29, 29, 18, 32, 40, 68, 46, 24, 40, 48, 31, 40, 19, 36, 45, 57, 17, 18, 31, 31, 31, 25, 53, 42, 34, 21, 48, 30, 7, 56, 48, 25, 32, 52, 44, 32, 55, 57, 59, 63, 48, 33, 9, 12, 44, 42, 50, 44, 37, 56, 57, 26, 42, 27, 49, 31, 24, 14, 31, 51, 26, 15, 27, 37, 37, 57, 30, 53, 41, 12, 57, 42, 27, 31, 40, 18, 56, 22, 37, 48, 30, 35, 36, 37, 32, 35, 49, 35, 34, 38, 26, 57, 60, 46, 32, 50, 37, 41, 36, 45, 47, 40, 45, 29, 18, 40, 53, 52, 42, 33, 26, 44, 32, 39, 60, 43, 60, 24, 44, 75, 55, 27, 32, 19, 20, 42, 21, 41, 41, 47, 34, 46, 55, 38, 35, 49, 36, 45, 34, 22, 41, 68, 31, 12, 36, 27, 52, 46, 26, 15, 37, 59, 26, 52, 38, 35, 54, 13, 48, 46, 55, 57, 39, 52, 35, 44, 52, 24, 51, 41, 59, 53, 36, 38, 62, 44, 58, 18, 41, 44, 44, 26, 38, 35, 42, 49, 52, 37, 33, 46, 56, 42, 44, 47, 63, 24, 47, 69, 31, 32, 11, 23, 46, 43, 53, 65, 56, 17, 54, 29, 36, 38, 54, 33, 37, 53, 46, 30, 46, 28, 30, 41, 31, 23, 49, 35, 33, 62, 43, 44, 30, 18, 52, 57, 38, 42, 30, 42, 44, 44, 39, 46, 50, 44, 27, 61, 29, 31, 33, 41, 68, 49, 36, 13, 32, 62, 41, 59, 39, 24, 12, 57, 53, 31, 66, 19, 47, 47, 51, 60, 21, 41, 50, 49, 31, 26, 64, 26, 48, 29, 4, 35, 48, 51, 52, 33, 23, 26, 60, 44, 55, 23, 44, 41, 47, 52, 26, 13, 75, 12, 53, 43, 54, 40, 57, 36, 17, 33, 49, 25, 54, 10, 34, 43, 28, 37, 48, 31, 25, 54, 22, 70, 55, 39, 57, 39, 14, 39, 20, 57, 39, 35, 42, 40, 35, 30, 70, 24, 43, 42, 28, 43, 13, 32, 19, 42, 53, 63, 31, 44, 19, 41, 29, 51, 30, 61, 45, 43, 47, 65, 56, 53, 23, 27, 54, 39, 56, 47, 50, 54, 49, 51, 15, 35, 32, 68, 41, 76, 16, 43, 36, 23, 40, 43, 12, 30, 56, 57, 47, 18, 31, 53, 22, 47, 21, 39, 47, 43, 29, 51, 29, 39, 36, 54, 24, 30, 62, 36, 70, 16, 46, 24, 15, 26, 20, 42, 55, 29, 57, 59, 30, 47, 60, 37, 43, 43, 27, 42, 55, 26, 12, 16, 45, 42, 57, 39, 22, 37, 38, 41, 38, 46, 22, 10, 51, 32, 38, 41, 17, 17, 28, 35, 43, 25, 51, 35, 45, 67, 42, 18, 41, 35, 77, 30, 20, 46, 46, 43, 44, 41, 50, 29, 45, 26, 31, 41, 32, 44, 31, 58, 26, 30, 66, 14, 55, 30, 19, 48, 55, 53, 15, 64, 32, 43, 21, 40, 78, 37, 29, 46, 29, 25, 40, 67, 32, 53, 29, 48, 28, 48, 26, 70, 53, 52, 47, 19, 22, 44, 49, 48, 29, 55, 44, 30, 55, 32, 50, 51, 45, 63, 71, 28, 13, 26, 48, 34, 43, 49, 39, 38, 69, 14, 32, 38, 50, 48, 37, 50, 33, 52, 28, 39, 46, 37, 30, 28, 28, 32, 35, 24, 38, 33, 36, 52, 37, 27, 32, 15, 41, 36, 53, 23, 33, 11, 43, 48, 32, 50, 35, 69, 31, 39, 10, 22, 18, 40, 21, 8, 39, 39, 32, 28, 35, 61, 47, 28, 41, 61, 71, 39, 37, 42, 55, 46, 23, 42, 64, 28, 33, 22, 65, 26, 35, 26, 23, 22, 53, 51, 50, 22, 50, 49, 28, 15, 48, 58, 53, 51, 44, 25, 26, 59, 47, 51, 25, 21, 40, 32, 26, 35, 68, 34, 17, 59, 63, 29, 22, 27, 8, 21, 49, 43, 46, 28, 53, 43, 16, 58, 56, 56, 38, 41, 53, 51, 58, 50, 52, 31, 44, 26, 36, 52, 38, 14, 31, 40, 24, 52, 58, 37, 56, 43, 62, 58, 25, 55, 30, 40, 60, 26, 23, 26, 61, 18, 43, 43, 47, 21, 38, 51, 33, 60, 39, 40, 40, 58, 38, 43, 31, 49, 28, 20, 48, 36, 42, 28, 36, 22, 62, 19, 52, 28, 47, 51, 58, 56, 32, 29, 75, 55, 32, 40, 34, 47, 57, 49, 32, 41, 20, 25, 38, 42, 30, 53, 24, 25, 53, 42, 17, 29, 21, 44, 46, 33, 32, 54, 35, 48, 30, 66, 43, 44, 71, 66, 46, 57, 64, 9, 41, 22, 39, 45, 43, 33, 26, 46, 41, 34, 32, 66, 18, 40, 22, 52, 29, 73, 31, 36, 36, 50, 26, 56, 62, 19, 76, 43, 39, 55, 39, 44, 58, 15, 27, 16, 47, 35, 50, 23, 58, 57, 44, 53, 48, 24, 63, 20, 39, 40, 39, 30, 38, 32, 44, 29, 43, 30, 49, 45, 45, 42, 69, 16, 26, 57, 36, 37, 56, 47, 15, 57, 64, 36, 50, 42, 39, 9, 45, 14, 36, 33, 34, 47, 32, 52, 26, 41, 33, 19, 43, 15, 25, 55, 59, 33, 33, 32, 44, 56, 67, 84, 33, 42, 44, 61, 47, 24, 71, 29, 22, 36, 33, 41, 19, 36, 24, 51, 36, 29, 26, 26, 35, 28, 38, 49, 58, 35, 47, 31, 43, 30, 23, 19, 29, 33, 50, 44, 71, 13, 20, 22, 31, 44, 62, 23, 25, 31, 24, 48, 25, 58, 32, 31, 37, 34, 63, 56, 16, 59, 51, 25, 30, 69, 32, 39, 50, 55, 28, 37, 87, 35, 70, 52, 33, 41, 47, 9, 52, 55, 32, 59, 47, 79, 35, 55, 12, 25, 24, 36, 18, 52, 34, 28, 56, 20, 35, 24, 40, 61, 42, 61, 29, 29, 30, 64, 45, 22, 45, 28, 45, 30, 46, 47, 33, 25, 34, 43, 53, 41, 20, 43, 60, 49, 46, 55, 50, 32, 45, 33, 62, 14, 57, 54, 35, 26, 58, 36, 52, 68, 29, 56, 30, 13, 38, 22, 30, 33, 52, 35, 63, 42, 50, 44, 23, 52, 37, 17, 56, 49, 44, 50, 50, 48, 37, 52, 35, 43, 46, 12, 52, 45, 34, 36, 22, 46, 51, 50, 33, 34, 35, 25, 28, 71, 33, 34, 10, 19, 20, 42, 39, 73, 37, 39, 30, 43, 40, 15, 55, 35, 32, 49, 51, 41, 55, 42, 44, 46, 20, 44, 61, 46, 55, 34, 27, 32, 33, 41, 56, 33, 63, 7, 34, 7, 36, 36, 50, 15, 30, 45, 29, 39, 62, 30, 66, 37, 40, 61, 35, 25, 64, 20, 38, 29, 17, 23, 41, 42, 50, 49, 45, 27, 28, 46, 69, 24, 57, 34, 43, 22, 34, 19, 30, 21, 11, 62, 47, 44, 50, 37, 39, 32, 33, 10, 56, 39, 17, 35, 57, 42, 55, 41, 30, 38, 27, 44, 28, 31, 36, 52, 17, 12, 37, 47, 48, 20, 55, 47, 38, 62, 48, 41, 48, 46, 22, 59, 37, 39, 30, 39, 32, 19, 51, 33, 61, 52, 46, 47, 34, 32, 44, 41, 42, 64, 23, 31, 48, 62, 19, 50, 34, 40, 21, 43, 19, 31, 57, 37, 52, 69, 49, 45, 28, 35, 23, 21, 35, 27, 41, 58, 8, 20, 41, 37, 46, 26, 45, 21, 39, 54, 21, 41, 41, 26, 58, 16, 69, 49, 26, 30, 32, 63, 51, 30, 74, 42, 36, 46, 31, 54, 24, 27, 21, 62, 30, 41, 34, 62, 59, 21, 40, 22, 29, 69, 31, 17, 36, 44, 36, 65, 49, 52, 52, 22, 51, 35, 55, 28, 43, 28, 45, 28, 48, 49, 47, 41, 34, 60, 28, 45, 32, 77, 44, 36, 25, 58, 17, 50, 51, 39, 40, 9, 52, 21, 15, 41, 34, 49, 57, 28, 21, 47, 26, 68, 47, 13, 54, 49, 26, 63, 34, 52, 35, 28, 7, 46, 63, 17, 20, 32, 27, 42, 17, 55, 50, 14, 33, 45, 36, 15, 10, 46, 25, 41, 49, 67, 20, 27, 49, 28, 36, 68, 37, 34, 59, 44, 55, 34, 69, 51, 56, 36, 30, 63, 60, 84, 48, 44, 44, 47, 34, 58, 45, 39, 23, 33, 39, 85, 64, 56, 42, 46, 43, 35, 32, 55, 28, 46, 23, 58, 28, 31, 54, 52, 31, 48, 35, 50, 24, 35, 54, 13, 10, 23, 51, 38, 24, 53, 3, 18, 34, 55, 54, 23, 42, 54, 12, 36, 50, 39, 43, 29, 38, 36, 41, 40, 36, 32, 29, 46, 37, 69, 36, 36, 50, 40, 28, 21, 45, 42, 16, 49, 50, 36, 37, 24, 30, 32, 29, 36, 20, 57, 16, 25, 53, 49, 23, 51, 40, 22, 59, 32, 45, 40, 31, 44, 39, 26, 29, 38, 60, 41, 71, 39, 37, 20, 26, 39, 32, 40, 45, 43, 67, 32, 45, 53, 29, 54, 36, 41, 33, 24, 57, 51, 55, 40, 64, 25, 27, 20, 18, 31, 43, 18, 24, 30, 25, 48, 53, 18, 39, 37, 54, 25, 35, 31, 35, 34, 30, 44, 12, 45, 31, 44, 38, 17, 50, 31, 31, 37, 42, 43, 33, 35, 22, 26, 48, 47, 33, 58, 29, 53, 31, 27, 66, 6, 60, 46, 36, 27, 66, 54, 57, 71, 5, 12, 42, 42, 15, 28, 43, 71, 21, 53, 48, 33, 27, 55, 14, 51, 34, 17, 53, 30, 32, 37, 59, 39, 29, 64, 50, 48, 51, 32, 28, 29, 32, 49, 18, 58, 49, 46, 35, 50, 40, 48, 33, 27, 35, 51, 38, 51, 57, 14, 78, 34, 18, 33, 33, 35, 45, 34, 40, 12, 25, 53, 56, 27, 31, 40, 27, 48, 68, 48, 29, 42, 19, 38, 53, 33, 19, 54, 17, 27, 42, 69, 60, 37, 65, 57, 55, 65, 48, 42, 76, 23, 26, 64, 52, 55, 6, 27, 26, 29, 30, 26, 64, 50, 59, 54, 58, 34, 47, 42, 50, 55, 53, 24, 28, 21, 51, 39, 56, 37, 49, 37, 56, 37, 58, 49, 39, 61, 40, 41, 19, 50, 65, 50, 53, 45, 54, 20, 30, 29, 27, 53, 37, 56, 24, 37, 54, 46, 18, 11, 43, 19, 34, 22, 27, 29, 35, 48, 56, 48, 53, 27, 38, 39, 26, 33, 15, 62, 28, 56, 43, 31, 15, 45, 50, 23, 49, 27, 57, 25, 36, 32, 54, 60, 38, 33, 28, 32, 49, 34, 14, 27, 58, 20, 21, 23, 43, 38, 29, 52, 78, 41, 63, 50, 38, 36, 39, 65, 36, 38, 61, 59, 47, 45, 17, 57, 24, 69, 74, 23, 50, 32, 35, 55, 42, 54, 47, 29, 52, 42, 27, 12, 60, 11, 33, 28, 48, 38, 25, 45, 59, 28, 61, 42, 33, 29, 27, 64, 20, 27, 15, 56, 15, 64, 34, 41, 27, 77, 52, 51, 36, 40, 43, 59, 23, 19, 49, 44, 47, 45, 37, 38, 39, 31, 35, 41, 18, 55, 38, 60, 38, 20, 52, 21, 26, 49, 73, 35, 29, 32, 29, 17, 47, 31, 38, 36, 31, 33, 22, 14, 17, 44, 72, 54, 58, 32, 49, 29, 28, 50, 62, 42, 35, 30, 22, 35, 29, 40, 43, 42, 50, 33, 42, 61, 42, 40, 34, 44, 30, 15, 64, 48, 35, 25, 44, 41, 53, 26, 46, 61, 38, 20, 39, 63, 24, 34, 52, 17, 30, 41, 45, 40, 55, 56, 27, 44, 31, 23, 24, 52, 39, 24, 51, 46, 60, 27, 52, 34, 62, 22, 48, 58, 38, 39, 60, 72, 24, 51, 51, 12, 48, 7, 20, 19, 46, 27, 45, 21, 31, 34, 35, 50, 6, 40, 45, 47, 42, 37, 24, 66, 43, 39, 40, 64, 30, 48, 9, 47, 47, 59, 40, 34, 46, 33, 45, 44, 49, 34, 56, 48, 31, 39, 58, 62, 30, 24, 42, 28, 59, 57, 61, 38, 60, 35, 23, 46, 46, 40, 44, 43, 38, 34, 51, 49, 49, 39, 37, 21, 74, 48, 80, 39, 30, 23, 53, 48, 42, 20, 44, 35, 53, 34, 52, 14, 32, 73, 36, 24, 41, 42, 46, 39, 35, 40, 18, 14, 34, 27, 38, 54, 28, 29, 41, 71, 18, 48, 41, 32, 34, 13, 37, 24, 23, 38, 47, 42, 47, 53, 38, 31, 9, 37, 59, 33, 29, 67, 9, 27, 44, 53, 13, 29, 38, 52, 32, 31, 22, 54, 43, 42, 20, 32, 43, 17, 60, 17, 38, 40, 25, 67, 50, 40, 16, 72, 41, 43, 12, 47, 10, 34, 31, 28, 43, 63, 55, 42, 17, 31, 62, 53, 19, 22, 28, 46, 42, 29, 76, 17, 21, 41, 31, 32, 42, 43, 43, 24, 36, 59, 5, 60, 37, 18, 46, 9, 48, 53, 51, 60, 40, 21, 9, 19, 38, 44, 32, 41, 30, 43, 52, 26, 20, 46, 37, 40, 54, 40, 36, 10, 29, 54, 56, 19, 35, 59, 33, 42, 39, 32, 50, 31, 33, 57, 15, 32, 34, 41, 55, 43, 55, 59, 41, 69, 32, 34, 21, 34, 32, 43, 55, 27, 28, 49, 22, 34, 37, 36, 39, 58, 42, 45, 50, 14, 39, 56, 46, 73, 21, 29, 37, 34, 56, 55, 37, 44, 49, 40, 51, 64, 64, 62, 60, 10, 43, 34, 43, 20, 31, 44, 41, 40, 29, 57, 68, 47, 44, 28, 27, 34, 53, 49, 48, 38, 51, 25, 15, 31, 28, 42, 50, 37, 33, 38, 24, 36, 29, 38, 65, 48, 60, 40, 40, 42, 10, 36, 36, 46, 64, 45, 38, 51, 20, 45, 39, 38, 44, 12, 61, 27, 44, 62, 50, 69, 57, 58, 53, 31, 56, 29, 39, 21, 35, 40, 29, 36, 28, 56, 15, 55, 59, 50, 46, 8, 38, 54, 15, 46, 29, 59, 56, 52, 33, 34, 74, 34, 38, 43, 25, 37, 42, 40, 64, 58, 31, 28, 47, 21, 60, 54, 62, 70, 27, 44, 17, 25, 35, 7, 58, 6, 68, 39, 37, 4, 44, 30, 41, 12, 42, 24, 31, 24, 58, 48, 37, 38, 44, 43, 45, 42, 31, 17, 41, 52, 55, 45, 24, 5, 56, 73, 25, 30, 36, 59, 24, 46, 18, 57, 30, 31, 34, 40, 61, 46, 49, 40, 44, 45, 20, 43, 33, 42, 38, 54, 10, 39, 42, 40, 12, 48, 36, 32, 33, 43, 38, 28, 28, 18, 61, 27, 23, 37, 51, 31, 30, 46, 22, 32, 27, 36, 44, 79, 45, 50, 44, 6, 33, 28, 31, 15, 36, 54, 43, 51, 51, 21, 57, 21, 24, 17, 53, 38, 41, 37, 18, 21, 27, 43, 42, 20, 18, 55, 21, 36, 43, 26, 38, 46, 44, 50, 27, 19, 45, 45, 39, 25, 56, 27, 45, 55, 36, 37, 30, 30, 27, 38, 44, 52, 30, 48, 42, 29, 27, 24, 14, 38, 18, 38, 52, 36, 17, 37, 53, 59, 61, 12, 27, 36, 24, 16, 22, 31, 55, 45, 54, 45, 51, 29, 32, 33, 46, 30, 49, 51, 47, 71, 52, 33, 12, 36, 39, 33, 53, 43, 32, 76, 39, 25, 31, 28, 14, 40, 70, 35, 30, 51, 44, 47, 39, 48, 43, 33, 37, 12, 34, 62, 46, 36, 44, 25, 69, 36, 24, 13, 34, 45, 28, 47, 27, 58, 14, 36, 45, 36, 35, 20, 55, 14, 29, 50, 50, 33, 28, 24, 38, 26, 68, 55, 20, 33, 47, 56, 67, 48, 39, 37, 50, 51, 29, 20, 34, 33, 53, 45, 28, 51, 50, 39, 53, 50, 58, 46, 43, 16, 31, 50, 71, 40, 41, 66, 40, 33, 38, 48, 52, 11, 28, 29, 49, 56, 23, 46, 51, 58, 49, 33, 47, 28, 41, 51, 25, 45, 41, 28, 39, 54, 41, 28, 26, 35, 33, 56, 45, 39, 27, 40, 48, 25, 40, 51, 51, 33, 32, 41, 10, 41, 55, 43, 26, 28, 50, 46, 29, 35, 19, 27, 28, 55, 36, 57, 64, 44, 34, 34, 32, 26, 30, 36, 20, 40, 6, 37, 33, 49, 68, 45, 34, 54, 52, 48, 65, 37, 35, 32, 48, 41, 48, 32, 43, 26, 41, 35, 41, 62, 35, 26, 45, 31, 30, 37, 23, 68, 40, 16, 28, 28, 24, 39, 46, 12, 40, 45, 44, 35, 53, 38, 42, 27, 32, 39, 53, 18, 30, 45, 58, 42, 36, 67, 24, 36, 38, 9, 56, 61, 47, 60, 58, 66, 14, 35, 32, 32, 58, 38, 40, 37, 38, 44, 57, 34, 75, 44, 33, 29, 53, 44, 32, 40, 35, 55, 13, 35, 52, 31, 47, 16, 35, 56, 39, 33, 46, 47, 24, 46, 21, 35, 35, 17, 31, 39, 39, 36, 17, 29, 42, 33, 29, 54, 56, 24, 28, 48, 15, 44, 35, 35, 39, 60, 42, 48, 43, 58, 36, 46, 30, 45, 40, 63, 42, 15, 54, 34, 30, 54, 34, 21, 19, 25, 21, 19, 47, 28, 58, 28, 11, 29, 36, 30, 56, 31, 38, 29, 48, 36, 34, 45, 35, 39, 55, 10, 31, 72, 44, 31, 44, 34, 15, 39, 5, 35, 35, 50, 66, 45, 50, 47, 40, 20, 22, 50, 34, 46, 55, 44, 55, 62, 38, 46, 45, 52, 27, 51, 33, 29, 16, 40, 37, 62, 37, 46, 26, 37, 47, 26, 39, 36, 35, 31, 48, 19, 41, 56, 44, 54, 67, 36, 27, 39, 31, 46, 19, 50, 29, 48, 28, 52, 49, 30, 39, 53, 54, 20, 29, 48, 40, 44, 49, 53, 19, 23, 33, 32, 47, 36, 42, 38, 24, 13, 52, 45, 52, 46, 59, 18, 31, 37, 35, 22, 26, 9, 12, 20, 36, 10, 41, 31, 48, 42, 44, 29, 38, 53, 27, 50, 46, 64, 22, 30, 37, 24, 50, 52, 32, 43, 51, 78, 70, 62, 34, 58, 27, 61, 27, 54, 59, 48, 42, 58, 67, 50, 24, 42, 30, 29, 36, 52, 53, 27, 20, 38, 9, 29, 17, 34, 26, 8, 32, 52, 27, 31, 35, 31, 23, 50, 24, 41, 67, 44, 69, 21, 30, 58, 33, 32, 44, 53, 41, 41, 40, 15, 48, 56, 39, 37, 59, 20, 61, 38, 44, 23, 28, 32, 54, 29, 33, 46, 42, 63, 58, 47, 37, 32, 12, 39, 46, 13, 56, 68, 49, 59, 35, 23, 13, 47, 27, 69, 4, 49, 35, 60, 41, 5, 28, 67, 51, 42, 45, 28, 36, 42, 52, 50, 46, 36, 35, 17, 33, 20, 23, 53, 38, 39, 43, 29, 37, 55, 44, 32, 35, 20, 63, 51, 39, 50, 30, 27, 80, 18, 53, 54, 51, 53, 39, 32, 63, 10, 31, 32, 39, 38, 44, 30, 37, 40, 44, 43, 30, 20, 44, 58, 70, 65, 54, 47, 40, 54, 36, 46, 48, 54, 31, 29, 47, 48, 27, 46, 24, 40, 50, 28, 50, 31, 19, 50, 61, 37, 36, 47, 25, 67, 31, 38, 19, 39, 25, 14, 76, 34, 52, 22, 55, 47, 20, 39, 34, 54, 40, 44, 59, 48, 41, 50, 29, 25, 42, 64, 38, 23, 55, 27, 40, 47, 24, 34, 66, 31, 56, 10, 46, 43, 45, 30, 48, 15, 28, 43, 50, 16, 35, 28, 45, 40, 38, 48, 16, 26, 30, 26, 30, 68, 67, 53, 44, 45, 51, 47, 45, 29, 45, 46, 46, 75, 21, 28, 30, 35, 44, 45, 42, 48, 33, 52, 49, 53, 39, 36, 25, 49, 45, 17, 20, 61, 18, 29, 68, 50, 47, 28, 41, 26, 36, 40, 16, 46, 26, 38, 37, 59, 56, 18, 57, 33, 65, 44, 42, 37, 55, 38, 46, 8, 16, 51, 27, 51, 54, 27, 12, 10, 48, 70, 19, 39, 39, 28, 36, 23, 33, 32, 31, 24, 7, 37, 21, 31, 36, 46, 21, 51, 61, 54, 24, 36, 74, 40, 49, 25, 40, 46, 19, 28, 44, 58, 10, 34, 43, 45, 30, 36, 48, 33, 50, 43, 50, 35, 16, 40, 36, 38, 35, 54, 37, 40, 42, 14, 35, 41, 47, 51, 50, 61, 36, 58, 30, 46, 44, 38, 20, 11, 34, 42, 59, 38, 71, 40, 25, 35, 52, 26, 66, 49, 36, 31, 24, 52, 58, 60, 7, 31, 49, 35, 61, 56, 46, 32, 19, 78, 35]}, 'test_3': {'capacity': 100, 'num_items': 5000, 'items': [55, 51, 16, 43, 30, 49, 52, 44, 48, 29, 52, 34, 37, 25, 53, 48, 33, 34, 37, 72, 42, 46, 13, 64, 42, 66, 60, 37, 27, 48, 32, 46, 41, 36, 52, 22, 17, 30, 32, 37, 39, 35, 43, 55, 49, 23, 43, 66, 36, 42, 30, 37, 29, 44, 29, 48, 51, 47, 60, 51, 40, 36, 55, 60, 42, 60, 54, 20, 28, 43, 46, 41, 39, 36, 22, 23, 22, 44, 44, 41, 35, 50, 17, 30, 24, 46, 32, 66, 39, 54, 34, 24, 41, 49, 37, 41, 5, 34, 49, 44, 24, 44, 20, 31, 46, 32, 86, 31, 48, 38, 49, 16, 46, 58, 18, 41, 26, 61, 48, 51, 16, 48, 30, 48, 21, 34, 13, 37, 59, 30, 34, 68, 59, 36, 28, 19, 61, 50, 14, 44, 43, 18, 48, 69, 55, 63, 69, 69, 25, 55, 44, 55, 29, 63, 50, 47, 37, 40, 35, 25, 25, 34, 49, 30, 40, 34, 47, 43, 65, 69, 47, 67, 36, 56, 18, 16, 34, 48, 31, 13, 61, 42, 24, 52, 42, 35, 37, 33, 17, 21, 49, 57, 47, 27, 25, 52, 20, 20, 36, 40, 46, 44, 59, 46, 47, 54, 38, 65, 68, 54, 47, 36, 61, 25, 53, 34, 21, 54, 61, 27, 31, 50, 42, 43, 25, 29, 32, 26, 26, 37, 33, 29, 30, 64, 37, 52, 43, 43, 47, 59, 37, 38, 33, 66, 34, 32, 53, 14, 67, 10, 35, 58, 50, 23, 36, 46, 52, 34, 48, 24, 28, 47, 49, 19, 60, 20, 23, 18, 34, 32, 62, 31, 50, 53, 26, 53, 27, 39, 40, 61, 48, 41, 40, 32, 33, 42, 30, 31, 50, 19, 36, 64, 46, 36, 29, 55, 49, 43, 42, 62, 47, 36, 49, 47, 27, 59, 24, 46, 40, 48, 35, 39, 62, 31, 67, 37, 15, 10, 17, 66, 48, 35, 24, 36, 41, 17, 34, 43, 70, 44, 55, 50, 35, 42, 14, 33, 63, 12, 62, 56, 60, 17, 26, 45, 62, 68, 24, 66, 24, 52, 27, 12, 68, 43, 41, 38, 75, 65, 51, 63, 20, 24, 32, 46, 41, 32, 51, 64, 60, 11, 59, 54, 47, 60, 26, 38, 76, 15, 46, 7, 25, 57, 23, 32, 34, 26, 25, 38, 59, 45, 38, 33, 31, 37, 37, 44, 46, 21, 22, 52, 29, 19, 39, 41, 39, 31, 51, 32, 23, 21, 30, 49, 64, 28, 49, 19, 48, 19, 49, 16, 34, 46, 61, 13, 45, 39, 36, 36, 32, 40, 29, 54, 34, 37, 38, 65, 27, 28, 38, 46, 34, 38, 50, 54, 34, 39, 39, 21, 38, 44, 21, 52, 59, 33, 69, 38, 54, 13, 44, 52, 32, 28, 44, 43, 58, 21, 52, 35, 42, 34, 49, 39, 26, 69, 25, 37, 49, 54, 56, 65, 43, 32, 36, 27, 40, 23, 48, 24, 13, 25, 38, 29, 40, 26, 36, 50, 47, 25, 59, 24, 45, 28, 41, 23, 55, 44, 49, 64, 14, 49, 13, 12, 14, 61, 37, 63, 45, 17, 33, 27, 32, 15, 48, 54, 28, 36, 24, 45, 43, 26, 55, 29, 60, 53, 30, 87, 48, 51, 47, 54, 38, 53, 51, 25, 48, 12, 30, 36, 80, 63, 30, 33, 38, 33, 32, 24, 12, 29, 41, 26, 64, 37, 24, 83, 27, 62, 52, 45, 23, 39, 37, 51, 52, 48, 23, 34, 51, 27, 41, 50, 52, 73, 23, 38, 38, 25, 36, 52, 79, 21, 42, 60, 68, 48, 23, 15, 33, 39, 50, 23, 39, 64, 51, 16, 27, 41, 70, 50, 34, 29, 44, 18, 63, 47, 14, 36, 45, 69, 71, 42, 11, 49, 10, 43, 31, 48, 54, 31, 40, 35, 40, 38, 33, 46, 43, 34, 26, 49, 8, 46, 11, 27, 27, 11, 64, 47, 37, 41, 68, 28, 31, 69, 36, 40, 45, 49, 55, 35, 46, 44, 66, 50, 53, 37, 30, 66, 14, 63, 39, 45, 42, 37, 48, 55, 54, 32, 18, 64, 39, 49, 68, 35, 40, 16, 51, 51, 41, 54, 41, 27, 17, 40, 36, 54, 58, 36, 46, 29, 34, 35, 18, 41, 59, 49, 44, 36, 50, 29, 36, 15, 58, 30, 15, 46, 26, 30, 62, 50, 35, 19, 35, 20, 32, 19, 69, 19, 40, 51, 51, 53, 17, 38, 40, 10, 43, 22, 72, 33, 70, 14, 48, 38, 50, 42, 21, 28, 36, 44, 67, 34, 22, 17, 18, 28, 49, 66, 26, 53, 41, 21, 8, 26, 39, 54, 45, 42, 28, 49, 62, 66, 41, 36, 41, 32, 31, 20, 42, 26, 39, 37, 29, 29, 21, 41, 26, 36, 57, 44, 45, 26, 42, 44, 45, 47, 61, 51, 27, 22, 44, 44, 25, 7, 36, 21, 53, 26, 38, 26, 28, 60, 57, 28, 65, 64, 33, 34, 29, 26, 48, 42, 46, 21, 31, 62, 58, 47, 56, 42, 50, 52, 41, 23, 28, 64, 11, 46, 36, 56, 44, 58, 58, 29, 13, 68, 46, 45, 15, 29, 53, 51, 58, 27, 35, 47, 39, 48, 34, 26, 36, 54, 60, 56, 67, 40, 39, 63, 47, 44, 24, 58, 48, 48, 49, 46, 41, 68, 42, 50, 73, 23, 23, 36, 41, 43, 20, 63, 36, 20, 39, 49, 25, 32, 53, 21, 31, 54, 30, 22, 28, 37, 57, 37, 41, 42, 21, 14, 48, 22, 49, 39, 21, 36, 19, 31, 64, 50, 12, 32, 58, 45, 35, 21, 49, 58, 69, 48, 37, 27, 44, 32, 20, 24, 35, 49, 54, 19, 53, 40, 49, 67, 26, 49, 70, 43, 30, 38, 27, 35, 57, 39, 45, 38, 41, 15, 21, 54, 26, 34, 46, 64, 36, 28, 45, 63, 57, 67, 22, 26, 8, 42, 47, 36, 66, 23, 42, 24, 16, 37, 39, 57, 54, 26, 33, 17, 21, 66, 26, 32, 35, 54, 40, 19, 59, 41, 45, 34, 45, 31, 32, 20, 35, 50, 24, 41, 93, 47, 30, 45, 32, 45, 37, 40, 67, 32, 14, 28, 41, 62, 34, 28, 33, 28, 41, 61, 37, 46, 23, 32, 33, 39, 37, 49, 36, 32, 61, 27, 68, 62, 52, 40, 39, 46, 23, 49, 17, 38, 31, 23, 17, 25, 70, 47, 46, 50, 15, 34, 56, 51, 48, 74, 27, 64, 11, 51, 46, 37, 35, 51, 23, 35, 36, 31, 55, 32, 33, 49, 12, 39, 48, 20, 35, 58, 70, 36, 52, 21, 46, 32, 41, 42, 42, 13, 14, 44, 31, 51, 47, 21, 45, 43, 38, 44, 44, 32, 54, 30, 51, 36, 8, 44, 14, 28, 35, 34, 40, 28, 16, 49, 21, 33, 39, 48, 65, 38, 58, 38, 35, 41, 36, 77, 33, 38, 29, 23, 20, 59, 38, 30, 32, 25, 27, 28, 45, 43, 42, 23, 20, 37, 29, 49, 51, 10, 73, 12, 33, 30, 21, 48, 38, 48, 46, 31, 37, 35, 26, 67, 21, 66, 55, 43, 26, 49, 52, 39, 33, 59, 33, 25, 54, 55, 16, 19, 34, 49, 42, 44, 26, 32, 40, 25, 53, 33, 36, 61, 66, 55, 78, 54, 31, 44, 40, 25, 31, 65, 57, 50, 25, 17, 52, 23, 50, 24, 54, 28, 56, 26, 41, 46, 43, 43, 46, 39, 26, 26, 40, 59, 31, 24, 30, 14, 53, 34, 54, 34, 46, 66, 51, 52, 56, 30, 45, 38, 22, 49, 55, 40, 24, 54, 41, 44, 38, 39, 40, 15, 7, 76, 42, 53, 44, 39, 39, 41, 38, 53, 23, 52, 44, 28, 62, 41, 69, 43, 60, 37, 33, 37, 69, 38, 49, 35, 37, 29, 22, 37, 52, 40, 40, 20, 18, 30, 39, 49, 10, 9, 62, 47, 46, 27, 79, 43, 37, 34, 57, 56, 45, 42, 44, 47, 21, 27, 59, 36, 17, 39, 45, 69, 28, 28, 48, 20, 47, 48, 60, 31, 56, 43, 54, 19, 19, 59, 67, 23, 48, 52, 26, 50, 18, 70, 22, 15, 42, 39, 29, 64, 23, 57, 24, 31, 12, 25, 20, 54, 49, 65, 60, 41, 32, 45, 41, 57, 54, 35, 16, 27, 54, 55, 71, 33, 21, 51, 39, 45, 29, 36, 28, 7, 8, 34, 38, 26, 33, 81, 62, 15, 31, 19, 42, 25, 47, 53, 45, 49, 52, 33, 42, 34, 59, 54, 45, 54, 31, 47, 52, 42, 26, 46, 36, 41, 54, 31, 52, 60, 42, 41, 47, 43, 19, 54, 17, 31, 34, 77, 49, 12, 27, 36, 61, 31, 47, 45, 53, 48, 44, 18, 45, 51, 21, 32, 20, 38, 32, 15, 35, 45, 34, 38, 35, 48, 60, 61, 37, 54, 26, 74, 56, 22, 38, 20, 24, 42, 26, 48, 58, 61, 45, 40, 48, 50, 25, 36, 67, 44, 52, 30, 69, 35, 39, 46, 65, 76, 41, 45, 28, 34, 41, 27, 61, 51, 18, 34, 45, 20, 29, 54, 27, 32, 65, 16, 27, 47, 25, 17, 38, 38, 35, 34, 22, 34, 36, 15, 49, 47, 78, 20, 28, 26, 42, 34, 32, 38, 42, 50, 32, 47, 37, 32, 52, 39, 30, 29, 58, 27, 25, 38, 50, 49, 39, 50, 43, 27, 55, 49, 49, 58, 31, 18, 41, 49, 49, 31, 12, 41, 68, 51, 83, 22, 38, 39, 65, 35, 17, 49, 28, 21, 19, 53, 40, 44, 67, 49, 17, 25, 31, 24, 29, 41, 26, 35, 38, 36, 61, 38, 37, 13, 49, 58, 37, 32, 57, 46, 39, 38, 25, 47, 17, 50, 33, 51, 44, 47, 47, 35, 42, 47, 50, 31, 46, 11, 28, 52, 22, 31, 50, 54, 22, 39, 36, 29, 34, 34, 60, 47, 29, 40, 49, 26, 51, 26, 52, 39, 49, 14, 52, 19, 34, 48, 39, 14, 57, 40, 49, 16, 68, 45, 30, 29, 55, 40, 42, 43, 33, 61, 38, 40, 23, 9, 47, 59, 38, 38, 39, 30, 59, 45, 81, 48, 62, 22, 40, 20, 46, 19, 62, 56, 40, 34, 35, 34, 26, 40, 34, 26, 48, 37, 22, 45, 26, 38, 13, 21, 37, 37, 31, 56, 47, 17, 42, 12, 35, 58, 29, 40, 39, 34, 25, 50, 49, 10, 58, 62, 28, 84, 47, 41, 48, 62, 54, 49, 53, 58, 33, 52, 43, 27, 29, 53, 81, 52, 31, 23, 37, 50, 68, 28, 30, 14, 39, 55, 44, 40, 37, 28, 31, 42, 40, 51, 45, 58, 67, 36, 39, 34, 26, 61, 49, 57, 51, 42, 26, 63, 46, 41, 58, 13, 49, 39, 43, 49, 23, 43, 51, 51, 20, 47, 15, 55, 72, 18, 21, 25, 37, 49, 39, 45, 52, 39, 73, 31, 38, 36, 36, 29, 33, 33, 21, 22, 36, 41, 65, 69, 28, 28, 26, 59, 26, 41, 35, 14, 22, 44, 43, 40, 34, 54, 29, 36, 50, 37, 44, 48, 26, 44, 64, 32, 48, 46, 50, 37, 45, 40, 11, 31, 14, 32, 42, 40, 36, 34, 36, 48, 29, 16, 48, 55, 54, 58, 32, 35, 55, 28, 43, 24, 38, 52, 34, 34, 20, 63, 31, 57, 38, 31, 27, 51, 34, 18, 60, 47, 55, 39, 41, 39, 27, 39, 67, 57, 41, 21, 13, 39, 42, 28, 33, 32, 31, 57, 18, 50, 32, 16, 42, 44, 15, 31, 51, 48, 15, 22, 40, 29, 26, 14, 51, 38, 39, 40, 21, 52, 59, 23, 38, 26, 45, 32, 61, 40, 51, 35, 44, 53, 38, 49, 29, 26, 21, 37, 20, 54, 29, 56, 28, 75, 29, 47, 59, 36, 24, 31, 32, 51, 43, 45, 72, 44, 30, 62, 39, 30, 36, 37, 33, 31, 32, 39, 30, 64, 46, 25, 22, 70, 45, 30, 62, 67, 61, 40, 9, 41, 5, 30, 52, 32, 38, 8, 13, 67, 27, 40, 36, 36, 38, 31, 27, 39, 33, 72, 56, 41, 64, 51, 62, 21, 36, 51, 30, 36, 29, 33, 17, 43, 18, 38, 24, 59, 30, 36, 15, 27, 45, 14, 47, 29, 36, 51, 58, 45, 49, 61, 37, 45, 38, 58, 30, 58, 52, 29, 65, 38, 43, 18, 30, 28, 41, 42, 11, 51, 22, 57, 38, 54, 36, 55, 38, 29, 46, 35, 27, 26, 56, 47, 27, 29, 22, 38, 13, 24, 32, 42, 32, 50, 46, 35, 24, 41, 54, 43, 47, 36, 37, 30, 48, 34, 55, 38, 35, 75, 28, 12, 57, 39, 21, 18, 33, 17, 26, 48, 68, 55, 50, 50, 30, 45, 26, 37, 52, 53, 22, 73, 54, 39, 24, 26, 27, 23, 38, 41, 48, 47, 30, 36, 22, 38, 27, 26, 33, 58, 70, 68, 8, 29, 9, 19, 17, 32, 42, 50, 60, 43, 51, 25, 30, 56, 22, 70, 52, 26, 22, 53, 47, 23, 19, 61, 46, 39, 47, 11, 39, 29, 37, 70, 52, 41, 37, 36, 51, 33, 29, 41, 46, 44, 24, 24, 58, 11, 53, 34, 44, 53, 39, 52, 74, 16, 53, 46, 38, 71, 57, 26, 38, 54, 54, 40, 47, 81, 31, 52, 29, 29, 52, 64, 30, 63, 40, 26, 42, 56, 55, 36, 37, 19, 40, 51, 29, 51, 57, 45, 31, 57, 32, 27, 39, 42, 31, 23, 42, 27, 48, 31, 35, 25, 52, 58, 62, 6, 80, 29, 72, 54, 43, 48, 29, 50, 49, 19, 53, 48, 36, 35, 35, 9, 55, 37, 20, 56, 46, 50, 13, 48, 13, 18, 41, 52, 35, 33, 43, 39, 25, 31, 41, 32, 55, 28, 41, 43, 15, 66, 16, 47, 18, 40, 25, 27, 45, 39, 30, 43, 52, 44, 24, 74, 45, 36, 28, 46, 43, 7, 27, 48, 44, 80, 39, 46, 39, 31, 34, 29, 19, 8, 36, 37, 12, 43, 54, 20, 22, 31, 28, 45, 19, 40, 47, 44, 54, 32, 20, 39, 51, 61, 42, 33, 72, 38, 30, 48, 28, 36, 32, 31, 59, 38, 37, 67, 68, 14, 20, 33, 59, 44, 35, 18, 49, 53, 63, 27, 45, 41, 38, 35, 42, 13, 34, 23, 26, 64, 21, 24, 55, 42, 52, 35, 26, 24, 33, 29, 51, 50, 21, 42, 58, 48, 25, 34, 46, 21, 44, 29, 42, 43, 55, 48, 38, 54, 27, 38, 29, 29, 40, 51, 20, 66, 29, 39, 41, 23, 54, 27, 37, 44, 29, 40, 52, 18, 35, 25, 31, 41, 22, 28, 22, 55, 55, 27, 17, 69, 75, 33, 32, 65, 34, 60, 40, 39, 36, 21, 36, 59, 10, 44, 16, 41, 25, 11, 30, 33, 40, 63, 27, 38, 56, 49, 49, 33, 30, 26, 61, 28, 26, 48, 37, 42, 46, 25, 50, 21, 33, 78, 26, 19, 36, 34, 40, 33, 42, 50, 35, 33, 52, 46, 46, 28, 23, 55, 26, 30, 31, 42, 40, 63, 63, 43, 32, 42, 32, 13, 37, 53, 42, 22, 51, 61, 18, 25, 20, 36, 20, 36, 19, 41, 30, 64, 57, 38, 35, 31, 40, 46, 45, 31, 42, 24, 37, 33, 28, 53, 9, 35, 20, 30, 9, 49, 30, 52, 51, 61, 41, 11, 29, 37, 50, 49, 32, 50, 72, 49, 58, 32, 45, 30, 19, 30, 52, 16, 41, 38, 41, 41, 33, 22, 31, 44, 57, 24, 67, 52, 29, 29, 10, 56, 60, 76, 33, 69, 26, 32, 62, 18, 20, 38, 16, 50, 30, 31, 36, 40, 46, 26, 75, 34, 46, 34, 61, 28, 65, 37, 30, 62, 65, 35, 50, 27, 51, 43, 34, 32, 22, 41, 30, 35, 30, 60, 44, 50, 46, 26, 27, 39, 62, 23, 25, 36, 41, 50, 35, 36, 21, 28, 18, 58, 22, 11, 27, 26, 41, 36, 30, 60, 37, 64, 29, 56, 21, 44, 33, 49, 49, 53, 38, 41, 24, 60, 38, 26, 60, 9, 54, 42, 23, 46, 77, 23, 42, 37, 30, 23, 15, 26, 35, 21, 25, 39, 45, 28, 58, 52, 26, 34, 55, 59, 11, 21, 7, 57, 17, 28, 41, 54, 29, 38, 39, 29, 19, 39, 45, 52, 54, 40, 38, 22, 42, 46, 35, 29, 20, 35, 21, 42, 40, 32, 50, 27, 48, 68, 25, 44, 42, 64, 35, 77, 15, 32, 32, 31, 45, 52, 14, 63, 48, 17, 45, 37, 16, 21, 13, 39, 26, 29, 49, 24, 41, 39, 43, 41, 35, 34, 21, 39, 37, 23, 28, 51, 51, 27, 33, 36, 40, 49, 39, 40, 50, 41, 62, 49, 59, 39, 48, 49, 16, 39, 51, 47, 32, 51, 27, 36, 39, 28, 50, 27, 28, 18, 36, 37, 28, 23, 27, 15, 60, 49, 29, 13, 24, 32, 36, 51, 23, 27, 70, 13, 28, 57, 19, 61, 27, 60, 23, 46, 39, 43, 22, 69, 42, 30, 39, 9, 17, 53, 27, 45, 52, 29, 7, 13, 45, 45, 47, 36, 65, 49, 59, 41, 33, 26, 65, 21, 23, 19, 48, 27, 56, 38, 57, 47, 42, 63, 45, 33, 15, 22, 14, 15, 30, 51, 38, 39, 41, 48, 31, 39, 61, 29, 75, 47, 35, 58, 50, 26, 40, 53, 65, 53, 43, 44, 56, 45, 60, 40, 22, 33, 59, 53, 47, 56, 67, 47, 46, 45, 34, 75, 48, 29, 62, 24, 34, 36, 55, 31, 67, 17, 36, 29, 51, 41, 33, 25, 48, 38, 16, 63, 46, 43, 46, 45, 35, 45, 77, 35, 28, 66, 51, 20, 41, 36, 23, 65, 40, 37, 30, 51, 23, 38, 15, 63, 47, 37, 24, 18, 28, 42, 27, 44, 36, 46, 43, 41, 46, 57, 49, 43, 40, 44, 53, 23, 33, 63, 30, 32, 36, 47, 43, 35, 7, 67, 48, 33, 54, 12, 64, 57, 12, 52, 8, 58, 45, 42, 43, 54, 54, 59, 32, 35, 36, 20, 43, 40, 37, 45, 38, 41, 50, 29, 15, 34, 73, 30, 37, 55, 47, 21, 33, 37, 39, 60, 14, 52, 67, 48, 12, 37, 40, 57, 59, 64, 47, 13, 31, 57, 59, 30, 30, 22, 39, 38, 13, 32, 46, 24, 47, 16, 44, 32, 49, 28, 61, 65, 24, 24, 19, 22, 42, 20, 51, 43, 25, 27, 54, 28, 55, 36, 27, 32, 27, 55, 51, 41, 46, 37, 53, 19, 68, 44, 65, 29, 22, 55, 14, 59, 76, 50, 37, 46, 49, 38, 20, 34, 58, 52, 62, 30, 48, 45, 37, 17, 51, 33, 41, 18, 34, 17, 22, 51, 48, 14, 69, 26, 47, 54, 31, 19, 49, 49, 53, 51, 50, 69, 53, 27, 24, 33, 48, 50, 37, 42, 48, 37, 49, 68, 34, 49, 22, 44, 26, 39, 32, 43, 32, 55, 46, 73, 42, 18, 57, 53, 27, 3, 46, 51, 49, 59, 57, 26, 34, 32, 22, 47, 60, 35, 42, 28, 71, 30, 35, 52, 54, 54, 35, 35, 34, 37, 42, 70, 42, 33, 35, 56, 24, 34, 52, 54, 53, 41, 45, 24, 16, 35, 65, 38, 35, 45, 18, 46, 16, 19, 25, 34, 30, 49, 54, 28, 32, 46, 42, 30, 32, 31, 38, 28, 43, 34, 51, 52, 58, 45, 31, 59, 24, 31, 52, 33, 53, 26, 48, 45, 61, 38, 57, 36, 28, 37, 41, 40, 47, 25, 54, 17, 50, 30, 56, 26, 42, 34, 23, 19, 70, 45, 47, 68, 39, 24, 35, 56, 39, 26, 25, 22, 49, 40, 38, 32, 31, 32, 56, 48, 45, 43, 40, 58, 44, 37, 54, 40, 19, 27, 12, 41, 34, 29, 17, 86, 50, 49, 38, 22, 72, 33, 19, 47, 47, 59, 64, 62, 65, 62, 29, 49, 43, 46, 30, 70, 59, 40, 34, 52, 47, 29, 42, 31, 28, 68, 52, 24, 32, 40, 18, 35, 28, 41, 31, 58, 29, 58, 36, 31, 32, 34, 48, 66, 32, 34, 48, 35, 31, 22, 38, 23, 21, 42, 41, 34, 24, 65, 55, 29, 47, 43, 56, 38, 18, 31, 32, 54, 18, 22, 43, 67, 55, 24, 39, 49, 35, 46, 28, 28, 49, 18, 52, 28, 74, 62, 60, 59, 23, 36, 28, 61, 58, 68, 16, 25, 41, 38, 21, 51, 28, 56, 43, 38, 24, 29, 65, 37, 44, 25, 41, 40, 36, 36, 38, 57, 63, 29, 41, 51, 16, 71, 59, 14, 19, 36, 20, 31, 59, 75, 24, 36, 52, 53, 29, 50, 51, 68, 24, 49, 49, 18, 63, 57, 46, 46, 34, 63, 38, 40, 39, 46, 45, 49, 3, 73, 23, 30, 43, 63, 45, 46, 33, 20, 65, 35, 65, 65, 44, 19, 38, 14, 41, 53, 54, 61, 55, 40, 28, 53, 38, 38, 49, 65, 61, 50, 31, 42, 48, 13, 26, 64, 71, 46, 29, 25, 28, 60, 62, 48, 37, 73, 43, 21, 32, 57, 48, 20, 43, 52, 45, 47, 67, 21, 29, 32, 16, 56, 32, 71, 35, 29, 38, 52, 37, 57, 52, 19, 39, 65, 26, 33, 36, 25, 47, 40, 44, 36, 55, 28, 25, 25, 27, 44, 42, 36, 64, 24, 30, 41, 24, 30, 54, 38, 35, 43, 27, 57, 51, 34, 20, 15, 45, 34, 34, 49, 14, 28, 61, 50, 53, 69, 33, 9, 29, 55, 54, 45, 27, 51, 29, 68, 52, 52, 59, 18, 28, 21, 35, 52, 13, 19, 34, 40, 41, 33, 43, 38, 54, 66, 77, 11, 31, 51, 59, 34, 25, 66, 44, 25, 41, 21, 52, 36, 40, 26, 32, 31, 42, 52, 41, 27, 41, 25, 27, 45, 38, 48, 45, 27, 44, 31, 19, 38, 21, 57, 38, 65, 36, 57, 37, 38, 73, 48, 51, 52, 54, 37, 55, 52, 20, 37, 38, 48, 16, 45, 20, 36, 43, 51, 12, 27, 60, 46, 63, 48, 67, 31, 42, 37, 64, 21, 30, 49, 47, 41, 29, 45, 52, 35, 32, 61, 13, 36, 44, 35, 34, 40, 26, 38, 46, 48, 60, 52, 19, 29, 35, 37, 22, 61, 23, 43, 28, 27, 63, 30, 34, 52, 35, 56, 50, 37, 31, 16, 51, 39, 53, 52, 16, 24, 57, 23, 29, 26, 39, 40, 51, 53, 38, 54, 47, 35, 44, 44, 51, 29, 43, 55, 61, 39, 33, 43, 42, 51, 11, 47, 29, 67, 25, 47, 10, 66, 61, 29, 61, 20, 18, 51, 50, 36, 22, 42, 44, 43, 55, 21, 23, 28, 68, 24, 31, 70, 73, 70, 43, 16, 49, 32, 19, 56, 73, 28, 32, 39, 15, 46, 18, 42, 20, 43, 15, 65, 66, 21, 59, 27, 44, 31, 31, 38, 72, 44, 32, 46, 41, 40, 58, 33, 53, 63, 22, 16, 38, 40, 24, 61, 19, 29, 11, 18, 23, 49, 22, 20, 60, 35, 53, 28, 59, 49, 56, 27, 35, 61, 47, 61, 50, 44, 40, 22, 29, 59, 61, 59, 21, 52, 32, 44, 36, 23, 55, 42, 12, 55, 33, 46, 49, 10, 56, 25, 29, 42, 53, 55, 50, 27, 18, 22, 50, 47, 41, 54, 20, 56, 62, 18, 40, 26, 6, 62, 41, 51, 33, 36, 53, 52, 60, 17, 48, 36, 30, 27, 41, 27, 57, 14, 41, 53, 36, 44, 52, 27, 20, 44, 71, 38, 18, 35, 39, 34, 42, 17, 58, 47, 22, 28, 48, 19, 37, 38, 39, 12, 29, 61, 19, 30, 18, 31, 41, 53, 35, 32, 52, 20, 55, 35, 41, 45, 45, 35, 35, 50, 37, 29, 28, 53, 26, 55, 51, 31, 44, 25, 29, 21, 45, 42, 35, 17, 51, 34, 47, 70, 51, 48, 11, 44, 15, 64, 40, 51, 25, 47, 48, 53, 49, 47, 47, 42, 52, 50, 42, 52, 39, 48, 35, 51, 53, 34, 49, 59, 47, 45, 58, 27, 26, 22, 37, 42, 66, 46, 29, 52, 54, 34, 52, 39, 33, 52, 43, 41, 35, 46, 37, 47, 28, 40, 11, 37, 51, 55, 28, 71, 54, 48, 18, 45, 52, 41, 25, 19, 24, 54, 45, 36, 31, 31, 10, 45, 36, 41, 44, 41, 30, 65, 57, 65, 68, 24, 34, 50, 40, 56, 36, 26, 33, 71, 45, 5, 21, 50, 52, 31, 22, 30, 35, 56, 18, 28, 15, 37, 28, 37, 60, 36, 25, 26, 55, 54, 44, 55, 49, 49, 16, 42, 19, 39, 42, 46, 46, 41, 30, 28, 42, 69, 52, 32, 61, 45, 38, 9, 24, 28, 13, 26, 54, 49, 37, 47, 38, 49, 22, 55, 53, 48, 19, 46, 33, 27, 61, 31, 47, 46, 25, 25, 54, 18, 52, 38, 36, 27, 11, 42, 44, 48, 71, 42, 22, 53, 67, 26, 32, 49, 40, 32, 16, 36, 52, 27, 39, 44, 62, 85, 51, 41, 55, 64, 50, 39, 27, 38, 40, 35, 61, 24, 14, 55, 48, 49, 50, 44, 14, 17, 42, 59, 30, 38, 23, 55, 29, 34, 34, 44, 55, 28, 9, 27, 49, 49, 12, 51, 38, 44, 46, 55, 26, 42, 38, 18, 53, 70, 28, 70, 58, 41, 42, 44, 31, 46, 43, 22, 59, 22, 17, 18, 24, 32, 31, 51, 26, 14, 65, 47, 47, 55, 55, 29, 27, 55, 36, 38, 52, 36, 31, 44, 29, 29, 36, 39, 34, 22, 32, 44, 45, 22, 37, 16, 65, 46, 41, 18, 52, 48, 36, 36, 8, 60, 64, 29, 61, 35, 41, 46, 29, 34, 71, 26, 49, 42, 46, 60, 56, 35, 11, 58, 27, 42, 55, 47, 39, 28, 36, 34, 59, 38, 50, 58, 34, 59, 31, 41, 39, 14, 42, 27, 33, 34, 45, 56, 63, 46, 40, 21, 45, 34, 33, 44, 49, 35, 25, 35, 19, 62, 42, 34, 49, 63, 43, 48, 59, 55, 37, 26, 16, 82, 61, 41, 19, 11, 32, 50, 47, 55, 27, 26, 21, 28, 40, 69, 42, 45, 74, 40, 19, 38, 21, 62, 39, 31, 59, 29, 59, 27, 27, 56, 37, 35, 28, 26, 59, 39, 74, 59, 31, 56, 67, 48, 31, 28, 72, 27, 29, 36, 26, 44, 32, 39, 39, 74, 61, 34, 47, 47, 55, 21, 32, 18, 55, 24, 33, 46, 37, 56, 29, 39, 55, 41, 34, 36, 31, 48, 31, 49, 31, 63, 10, 87, 42, 38, 28, 32, 46, 29, 34, 52, 59, 21, 17, 31, 30, 57, 37, 37, 26, 46, 29, 58, 63, 18, 66, 37, 55, 53, 43, 53, 21, 47, 31, 41, 38, 26, 49, 36, 53, 37, 45, 63, 48, 13, 48, 39, 26, 35, 45, 43, 27, 49, 39, 29, 16, 49, 26, 26, 44, 45, 21, 39, 41, 52, 15, 25, 53, 36, 58, 45, 50, 32, 47, 40, 47, 38, 54, 55, 58, 48, 43, 50, 60, 43, 48, 20, 13, 32, 44, 57, 39, 12, 44, 59, 58, 33, 43, 59, 65, 58, 41, 25, 51, 33, 54, 32, 32, 34, 41, 65, 41, 48, 34, 38, 14, 54, 40, 46, 73, 18, 33, 37, 30, 42, 39, 29, 71, 29, 21, 38, 17, 45, 49, 25, 52, 35, 34, 42, 14, 40, 19, 40, 35, 45, 28, 36, 32, 64, 43, 50, 33, 27, 60, 42, 36, 36, 49, 69, 61, 41, 60, 27, 55, 25, 42, 43, 22, 39, 57, 48, 35, 53, 52, 47, 41, 27, 58, 43, 59, 27, 48, 20, 31, 52, 26, 50, 23, 75, 49, 37, 45, 57, 56, 44, 39, 34, 45, 30, 18, 35, 30, 76, 28, 51, 40, 55, 61, 67, 53, 24, 42, 42, 36, 51, 53, 71, 39, 31, 30, 42, 35, 24, 41, 65, 51, 16, 43, 47, 41, 50, 41, 24, 60, 24, 32, 48, 24, 64, 31, 60, 43, 18, 44, 41, 17, 38, 12, 34, 42, 38, 48, 7, 13, 62, 63, 13, 41, 51, 31, 34, 29, 35, 48, 38, 15, 53, 32, 70, 40, 8, 31, 22, 27, 26, 54, 16, 43, 15, 22, 42, 48, 53, 64, 63, 20, 37, 40, 36, 4, 42, 42, 43, 32, 54, 66, 72, 30, 38, 30, 35, 41, 47, 21, 18, 63, 33, 31, 39, 59, 42, 20, 47, 27, 47, 59, 22, 34, 45, 14, 63, 40, 54, 25, 19, 44, 46, 60, 55, 47, 48, 16, 34, 37, 49, 22, 34, 17, 17, 59, 25, 44, 39, 47, 31, 40, 38, 50, 50, 50, 46, 45, 38, 39, 23, 12, 21, 47, 15, 37, 38, 20, 27, 58, 37, 70, 28, 18, 41, 12, 29, 30, 47, 27, 50, 29, 39, 17, 31, 17, 41, 29, 50, 42, 65, 32, 13, 17, 34, 54, 32, 48, 39, 67, 56, 15, 41, 36, 39, 28, 30, 45, 45, 34, 46, 30, 40, 56, 48, 26, 43, 22, 61, 31, 28, 29, 50, 16, 65, 54, 44, 52, 28, 32, 19, 42, 42, 39, 39, 59, 28, 60, 66, 23, 31, 24, 28, 13, 60, 38, 27, 35, 48, 59, 40, 62, 46, 70, 25, 54, 50, 32, 46, 57, 40, 38, 11, 45, 53, 21, 50, 30, 40, 43, 16, 32, 51, 42, 49, 60, 60, 37, 44, 73, 45, 55, 33, 42, 31, 49, 44, 21, 62, 50, 58, 26, 17, 71, 17, 27, 39, 50, 40, 43, 44, 31, 21, 44, 43, 22, 60, 29, 57, 20, 39, 44, 33, 34, 34, 41, 16, 25, 51, 23, 48, 17, 34, 24, 40, 27, 39, 28, 24, 26, 36, 37, 23, 57, 29, 56, 23, 41, 67, 35, 23, 10, 69, 56, 53, 50, 45, 32, 52, 39, 42, 30, 36, 47, 47, 36, 21, 21, 51, 24, 72, 10, 17, 52, 39, 39, 19, 20, 36, 54, 36, 34, 49, 63, 37, 24, 21, 43, 28, 65, 32, 29, 38, 23, 31, 9, 44, 51, 26, 52, 54, 28, 52, 46, 32, 50, 43, 46, 40, 24, 42, 38, 24, 46, 44, 40, 29, 35, 27, 55, 32, 28, 23, 13, 33, 31, 37, 18, 19, 37, 42, 18, 24, 36, 25, 54, 65, 6, 43, 27, 37, 68, 42, 33, 41, 48, 45, 66, 15, 27, 34]}, 'test_4': {'capacity': 100, 'num_items': 5000, 'items': [38, 34, 46, 40, 59, 55, 27, 37, 11, 63, 9, 31, 18, 52, 43, 50, 47, 34, 44, 47, 50, 41, 17, 40, 52, 55, 27, 29, 28, 54, 13, 57, 40, 15, 35, 27, 13, 28, 20, 8, 24, 47, 38, 48, 26, 34, 36, 47, 39, 10, 19, 57, 39, 44, 43, 56, 31, 48, 50, 26, 52, 52, 56, 41, 49, 37, 46, 37, 29, 47, 43, 30, 32, 24, 47, 37, 55, 47, 43, 10, 50, 27, 50, 27, 33, 51, 15, 43, 45, 48, 44, 59, 32, 44, 40, 46, 66, 39, 51, 30, 38, 25, 38, 28, 48, 50, 14, 41, 39, 31, 33, 38, 17, 24, 32, 23, 18, 55, 41, 40, 66, 35, 51, 63, 50, 88, 31, 63, 34, 51, 58, 32, 43, 59, 65, 43, 40, 31, 47, 66, 47, 45, 61, 24, 43, 53, 37, 36, 57, 19, 51, 6, 29, 41, 30, 11, 25, 50, 53, 53, 52, 42, 22, 29, 39, 25, 25, 34, 52, 50, 42, 59, 42, 50, 52, 49, 22, 60, 37, 50, 45, 24, 30, 40, 64, 33, 64, 47, 26, 55, 29, 39, 60, 27, 34, 41, 43, 35, 49, 40, 39, 51, 33, 45, 48, 64, 19, 47, 23, 41, 53, 35, 43, 33, 39, 34, 63, 27, 42, 34, 54, 52, 74, 27, 59, 71, 56, 33, 41, 16, 74, 34, 38, 41, 29, 30, 28, 28, 51, 29, 53, 27, 6, 15, 35, 63, 16, 52, 43, 21, 41, 21, 36, 32, 52, 39, 32, 25, 37, 52, 58, 21, 32, 35, 61, 52, 23, 58, 36, 19, 51, 61, 42, 40, 30, 34, 25, 28, 28, 19, 20, 30, 34, 63, 30, 53, 49, 24, 20, 54, 45, 18, 52, 49, 43, 37, 33, 44, 42, 43, 50, 33, 25, 29, 64, 43, 63, 45, 58, 59, 50, 73, 48, 34, 8, 26, 50, 21, 80, 24, 36, 26, 37, 65, 53, 50, 50, 60, 33, 81, 43, 57, 25, 67, 35, 35, 47, 52, 14, 60, 36, 27, 52, 24, 37, 44, 57, 42, 33, 37, 39, 43, 58, 44, 35, 46, 50, 47, 74, 25, 46, 27, 53, 54, 37, 46, 39, 27, 32, 49, 77, 37, 68, 34, 63, 56, 44, 45, 26, 74, 47, 52, 37, 37, 67, 26, 28, 39, 49, 25, 34, 40, 30, 56, 47, 50, 56, 32, 26, 50, 51, 40, 27, 61, 54, 42, 25, 43, 17, 41, 49, 26, 51, 22, 15, 52, 50, 31, 28, 31, 55, 32, 20, 33, 54, 49, 32, 42, 68, 47, 64, 6, 37, 38, 44, 37, 25, 9, 60, 44, 38, 40, 62, 48, 49, 55, 40, 55, 41, 40, 42, 51, 46, 61, 54, 45, 34, 48, 80, 63, 28, 31, 41, 49, 30, 41, 13, 48, 65, 59, 33, 42, 24, 48, 48, 30, 75, 43, 62, 60, 65, 15, 19, 33, 47, 36, 21, 31, 41, 23, 38, 51, 42, 58, 14, 42, 12, 20, 37, 35, 42, 43, 15, 43, 28, 42, 34, 55, 35, 43, 49, 28, 16, 40, 26, 27, 41, 35, 27, 46, 38, 31, 36, 21, 35, 64, 35, 33, 42, 13, 49, 51, 59, 53, 18, 27, 67, 20, 38, 26, 37, 33, 44, 31, 21, 23, 46, 38, 36, 65, 39, 52, 35, 42, 30, 38, 33, 45, 72, 21, 35, 54, 29, 57, 52, 33, 20, 30, 45, 33, 53, 73, 48, 49, 32, 36, 62, 66, 30, 56, 53, 29, 42, 24, 46, 39, 20, 43, 38, 52, 25, 58, 22, 38, 44, 48, 34, 40, 32, 8, 35, 45, 25, 68, 30, 45, 67, 56, 40, 22, 30, 74, 27, 48, 33, 67, 39, 11, 37, 53, 45, 57, 42, 45, 50, 47, 40, 40, 61, 64, 51, 28, 18, 12, 49, 43, 47, 44, 55, 31, 53, 37, 31, 47, 48, 31, 39, 42, 50, 14, 33, 42, 39, 50, 37, 55, 47, 50, 78, 37, 38, 30, 61, 39, 48, 30, 26, 48, 62, 46, 27, 54, 38, 36, 46, 34, 35, 64, 24, 39, 75, 29, 70, 38, 28, 39, 10, 24, 49, 47, 33, 47, 58, 30, 10, 26, 28, 43, 33, 29, 46, 36, 35, 19, 36, 10, 37, 31, 7, 42, 46, 63, 82, 49, 42, 42, 22, 54, 42, 50, 30, 51, 61, 48, 43, 29, 13, 33, 36, 58, 38, 47, 59, 57, 19, 33, 56, 7, 49, 41, 49, 11, 40, 68, 28, 11, 36, 39, 26, 26, 64, 25, 36, 18, 53, 33, 39, 45, 62, 30, 23, 38, 31, 26, 35, 26, 4, 44, 39, 34, 29, 23, 36, 62, 39, 41, 38, 14, 55, 19, 46, 57, 51, 37, 19, 27, 33, 36, 34, 38, 43, 27, 66, 30, 27, 46, 48, 48, 59, 81, 58, 40, 50, 35, 45, 51, 53, 53, 46, 52, 39, 17, 49, 35, 32, 41, 54, 46, 33, 42, 44, 24, 43, 45, 28, 29, 44, 44, 34, 46, 44, 17, 54, 27, 39, 42, 41, 26, 39, 57, 38, 17, 21, 52, 47, 24, 32, 37, 45, 13, 62, 48, 31, 42, 19, 23, 30, 50, 15, 31, 28, 42, 51, 45, 47, 23, 40, 52, 85, 54, 36, 20, 38, 34, 18, 25, 14, 34, 43, 21, 35, 39, 45, 33, 52, 24, 40, 51, 29, 26, 51, 41, 64, 57, 29, 45, 48, 35, 37, 38, 42, 46, 36, 43, 26, 41, 62, 62, 63, 6, 21, 30, 30, 21, 36, 33, 58, 41, 53, 29, 42, 9, 57, 27, 37, 48, 25, 23, 31, 33, 32, 42, 35, 15, 13, 61, 30, 16, 47, 25, 31, 62, 5, 50, 19, 38, 61, 27, 26, 35, 40, 24, 31, 30, 18, 18, 41, 36, 61, 11, 46, 7, 8, 42, 39, 28, 28, 33, 37, 37, 44, 6, 53, 35, 29, 35, 67, 29, 31, 49, 34, 46, 21, 23, 35, 48, 28, 38, 67, 45, 59, 44, 50, 61, 24, 49, 58, 9, 16, 40, 14, 18, 34, 47, 37, 56, 22, 41, 39, 35, 59, 57, 34, 24, 16, 48, 36, 38, 44, 23, 79, 24, 10, 36, 51, 32, 39, 43, 55, 28, 27, 25, 42, 45, 63, 24, 41, 47, 19, 32, 26, 57, 30, 24, 32, 62, 73, 35, 65, 30, 67, 38, 41, 30, 37, 48, 22, 58, 50, 8, 42, 44, 72, 42, 67, 24, 64, 55, 54, 42, 13, 13, 27, 27, 19, 53, 28, 33, 23, 36, 70, 54, 55, 37, 56, 35, 35, 53, 3, 43, 26, 43, 29, 69, 45, 61, 45, 46, 19, 40, 25, 43, 38, 62, 45, 58, 71, 45, 28, 42, 42, 11, 56, 58, 39, 35, 66, 23, 30, 42, 35, 50, 24, 44, 61, 56, 42, 41, 56, 48, 54, 21, 35, 51, 21, 29, 16, 44, 40, 50, 34, 38, 63, 58, 20, 51, 30, 39, 33, 29, 7, 39, 36, 59, 16, 45, 54, 49, 73, 30, 55, 32, 53, 83, 28, 44, 38, 54, 32, 23, 30, 50, 12, 52, 52, 46, 28, 47, 32, 26, 8, 60, 9, 36, 27, 27, 69, 49, 45, 31, 16, 48, 14, 31, 36, 44, 35, 48, 47, 51, 55, 40, 43, 42, 21, 51, 70, 53, 18, 37, 37, 53, 26, 28, 53, 65, 33, 27, 17, 42, 32, 19, 65, 31, 13, 32, 42, 24, 45, 54, 51, 48, 45, 54, 60, 31, 62, 43, 43, 43, 58, 33, 9, 46, 43, 16, 77, 52, 55, 46, 70, 78, 35, 42, 27, 24, 62, 40, 41, 43, 60, 43, 46, 27, 54, 47, 49, 51, 35, 42, 46, 21, 37, 47, 13, 39, 42, 21, 24, 45, 11, 50, 29, 36, 43, 49, 46, 28, 36, 47, 49, 42, 35, 57, 44, 41, 51, 59, 68, 37, 40, 32, 67, 21, 35, 28, 36, 35, 60, 39, 35, 39, 13, 51, 24, 8, 21, 59, 34, 42, 33, 41, 44, 22, 35, 33, 45, 80, 36, 42, 26, 25, 45, 46, 23, 30, 27, 53, 58, 50, 71, 39, 35, 49, 18, 56, 43, 16, 51, 24, 60, 53, 57, 51, 27, 34, 49, 47, 55, 37, 13, 11, 34, 53, 21, 24, 29, 61, 56, 45, 15, 33, 40, 31, 18, 36, 44, 9, 20, 41, 48, 34, 38, 35, 65, 48, 18, 11, 37, 28, 39, 51, 59, 42, 54, 44, 41, 10, 30, 54, 44, 38, 22, 44, 11, 54, 30, 40, 50, 49, 34, 26, 33, 39, 31, 44, 51, 47, 40, 41, 9, 42, 28, 45, 28, 36, 47, 50, 7, 47, 64, 43, 44, 46, 46, 11, 45, 26, 29, 31, 61, 44, 53, 71, 31, 69, 6, 42, 38, 51, 34, 51, 38, 45, 27, 29, 32, 25, 32, 25, 36, 43, 56, 49, 36, 36, 60, 46, 24, 36, 45, 57, 56, 41, 43, 35, 18, 52, 33, 41, 66, 71, 25, 28, 17, 11, 40, 34, 34, 12, 38, 31, 24, 52, 39, 19, 66, 55, 24, 43, 24, 33, 39, 66, 30, 24, 8, 62, 55, 64, 40, 59, 53, 42, 52, 29, 26, 24, 40, 32, 43, 30, 38, 55, 39, 16, 27, 33, 58, 31, 66, 35, 30, 26, 18, 34, 50, 35, 23, 30, 36, 36, 21, 33, 46, 52, 48, 31, 30, 29, 9, 27, 26, 40, 39, 45, 38, 60, 40, 34, 49, 45, 78, 34, 29, 56, 38, 20, 83, 19, 34, 37, 33, 54, 69, 47, 32, 49, 45, 48, 42, 19, 44, 30, 21, 39, 30, 29, 67, 37, 29, 33, 74, 38, 36, 10, 26, 27, 26, 49, 57, 56, 26, 34, 33, 9, 20, 22, 36, 53, 16, 69, 28, 35, 58, 53, 9, 50, 43, 30, 58, 49, 39, 40, 27, 42, 40, 42, 19, 39, 46, 58, 62, 30, 48, 30, 39, 36, 17, 37, 51, 18, 56, 48, 18, 24, 39, 21, 48, 8, 45, 36, 42, 44, 38, 50, 40, 51, 27, 23, 47, 16, 62, 49, 37, 44, 50, 17, 45, 45, 68, 12, 22, 59, 54, 38, 11, 43, 51, 21, 34, 29, 49, 41, 17, 33, 78, 18, 30, 47, 71, 33, 56, 44, 55, 46, 48, 50, 45, 31, 45, 27, 50, 46, 36, 43, 40, 59, 52, 53, 44, 29, 33, 59, 29, 55, 48, 38, 38, 21, 52, 22, 35, 38, 19, 31, 51, 47, 52, 41, 29, 26, 28, 60, 27, 40, 61, 44, 39, 36, 34, 37, 37, 39, 48, 73, 26, 24, 34, 29, 32, 59, 40, 41, 31, 14, 63, 19, 38, 45, 40, 58, 27, 55, 66, 45, 31, 28, 51, 22, 31, 15, 16, 31, 29, 34, 55, 52, 33, 46, 43, 70, 44, 40, 33, 31, 28, 52, 22, 37, 61, 17, 15, 21, 42, 54, 35, 25, 63, 15, 38, 52, 49, 58, 39, 65, 32, 31, 52, 43, 46, 44, 51, 34, 43, 56, 60, 80, 10, 46, 18, 17, 25, 37, 33, 34, 61, 31, 44, 64, 22, 30, 22, 35, 57, 38, 37, 42, 56, 39, 54, 25, 57, 52, 58, 36, 27, 36, 43, 24, 50, 60, 36, 16, 26, 18, 62, 50, 19, 39, 15, 34, 27, 49, 33, 22, 49, 45, 33, 43, 39, 65, 20, 44, 58, 42, 24, 38, 36, 23, 37, 41, 35, 33, 10, 31, 58, 59, 24, 36, 39, 61, 27, 43, 34, 37, 37, 31, 55, 44, 28, 11, 48, 34, 56, 41, 67, 51, 35, 26, 40, 22, 31, 46, 36, 21, 29, 22, 37, 31, 30, 68, 37, 47, 37, 33, 31, 72, 48, 33, 40, 44, 47, 52, 20, 25, 61, 27, 33, 57, 61, 46, 17, 29, 15, 68, 31, 35, 24, 54, 42, 24, 9, 12, 48, 52, 43, 43, 42, 23, 57, 53, 75, 36, 59, 46, 40, 38, 37, 51, 52, 30, 62, 41, 41, 71, 57, 20, 40, 51, 26, 60, 46, 57, 12, 9, 47, 26, 30, 30, 51, 27, 20, 47, 64, 36, 32, 34, 68, 31, 34, 18, 42, 24, 25, 17, 20, 78, 61, 47, 61, 19, 42, 27, 28, 52, 35, 14, 37, 51, 44, 44, 57, 48, 49, 46, 23, 41, 39, 37, 45, 70, 38, 30, 16, 36, 45, 26, 53, 29, 39, 29, 59, 28, 42, 31, 60, 52, 18, 34, 38, 52, 32, 40, 60, 81, 58, 55, 19, 28, 62, 54, 52, 35, 13, 9, 26, 26, 70, 49, 25, 30, 33, 12, 54, 29, 32, 51, 30, 64, 54, 28, 39, 23, 31, 22, 38, 40, 54, 42, 75, 34, 15, 33, 63, 37, 32, 21, 34, 47, 47, 39, 39, 49, 33, 31, 49, 43, 45, 55, 62, 39, 17, 53, 47, 39, 42, 22, 47, 64, 29, 17, 34, 24, 34, 47, 4, 32, 54, 63, 52, 32, 31, 43, 38, 36, 34, 21, 46, 60, 35, 25, 40, 18, 36, 50, 34, 27, 73, 48, 31, 48, 37, 19, 24, 61, 20, 36, 60, 32, 25, 39, 40, 38, 52, 21, 7, 52, 79, 60, 58, 57, 50, 50, 27, 40, 45, 21, 36, 28, 23, 38, 41, 35, 42, 6, 26, 23, 36, 19, 59, 41, 28, 45, 45, 57, 33, 55, 63, 42, 19, 35, 47, 17, 44, 31, 11, 7, 15, 36, 66, 42, 19, 41, 40, 30, 49, 49, 55, 51, 48, 21, 51, 39, 32, 42, 38, 61, 44, 26, 12, 25, 28, 52, 14, 56, 23, 47, 36, 51, 25, 31, 43, 34, 58, 25, 30, 34, 24, 90, 49, 36, 20, 55, 49, 43, 22, 64, 76, 33, 57, 50, 28, 42, 40, 23, 56, 39, 27, 23, 40, 47, 38, 49, 52, 39, 39, 43, 17, 44, 28, 43, 49, 53, 70, 31, 48, 63, 29, 25, 31, 45, 29, 40, 43, 46, 17, 27, 60, 56, 53, 54, 66, 30, 44, 29, 46, 32, 22, 40, 28, 34, 37, 19, 51, 42, 26, 19, 28, 66, 36, 33, 62, 23, 70, 62, 54, 49, 44, 39, 59, 58, 60, 39, 75, 41, 59, 33, 63, 51, 53, 38, 28, 52, 80, 39, 50, 29, 63, 48, 54, 32, 19, 11, 55, 27, 39, 36, 33, 18, 39, 15, 38, 23, 35, 46, 34, 31, 25, 26, 55, 30, 32, 22, 56, 45, 39, 31, 21, 28, 68, 36, 35, 45, 17, 36, 47, 23, 37, 17, 42, 53, 37, 42, 53, 45, 23, 34, 30, 26, 42, 39, 31, 43, 62, 55, 40, 75, 37, 41, 40, 26, 35, 26, 65, 18, 41, 37, 31, 43, 60, 62, 44, 42, 74, 41, 51, 30, 40, 49, 52, 55, 36, 22, 41, 50, 19, 53, 11, 32, 24, 18, 34, 62, 47, 39, 35, 34, 32, 35, 23, 36, 28, 37, 48, 65, 46, 57, 7, 26, 69, 38, 58, 50, 47, 38, 21, 50, 35, 45, 40, 46, 36, 48, 58, 36, 30, 54, 38, 56, 24, 44, 35, 30, 33, 27, 81, 44, 80, 45, 49, 38, 19, 23, 30, 27, 40, 71, 35, 67, 18, 33, 73, 46, 33, 44, 51, 31, 52, 44, 57, 51, 26, 27, 67, 23, 14, 36, 34, 41, 40, 55, 23, 37, 18, 21, 26, 43, 33, 42, 53, 21, 35, 52, 51, 30, 48, 30, 37, 50, 46, 8, 43, 30, 54, 53, 35, 58, 38, 47, 35, 8, 52, 38, 37, 81, 29, 43, 55, 37, 25, 49, 41, 39, 32, 38, 46, 59, 18, 46, 46, 44, 14, 35, 50, 49, 16, 33, 44, 36, 42, 77, 33, 36, 51, 39, 18, 58, 10, 43, 58, 60, 55, 41, 25, 63, 20, 39, 69, 29, 30, 65, 59, 23, 50, 25, 33, 36, 31, 44, 23, 54, 8, 49, 14, 31, 39, 61, 58, 32, 59, 37, 32, 57, 26, 38, 64, 61, 45, 37, 39, 45, 36, 28, 41, 38, 28, 20, 37, 57, 30, 36, 53, 42, 58, 26, 45, 18, 74, 53, 48, 52, 23, 49, 20, 35, 8, 27, 38, 65, 28, 7, 48, 29, 48, 50, 37, 41, 56, 36, 43, 44, 30, 32, 21, 48, 40, 29, 52, 56, 37, 57, 34, 16, 54, 20, 56, 33, 16, 38, 25, 74, 20, 52, 25, 60, 50, 29, 44, 60, 35, 32, 41, 42, 26, 43, 25, 30, 36, 31, 23, 48, 14, 29, 32, 59, 41, 32, 27, 23, 34, 41, 30, 46, 66, 52, 66, 31, 39, 25, 78, 24, 47, 33, 54, 7, 34, 56, 28, 33, 31, 40, 31, 15, 62, 42, 47, 44, 43, 25, 35, 32, 45, 6, 45, 20, 65, 13, 29, 47, 49, 43, 37, 51, 38, 50, 52, 48, 40, 55, 49, 23, 42, 38, 18, 21, 45, 56, 37, 33, 28, 50, 46, 43, 34, 67, 27, 22, 33, 44, 37, 27, 50, 46, 37, 14, 49, 24, 53, 34, 26, 54, 27, 35, 46, 45, 78, 18, 41, 25, 29, 30, 17, 17, 7, 50, 21, 69, 49, 61, 15, 35, 33, 7, 27, 20, 32, 45, 40, 54, 18, 15, 54, 42, 50, 41, 69, 45, 48, 49, 59, 27, 26, 63, 66, 35, 32, 50, 18, 31, 51, 62, 57, 59, 19, 47, 51, 32, 44, 65, 26, 43, 60, 65, 33, 50, 22, 32, 34, 45, 59, 90, 68, 52, 38, 37, 25, 46, 49, 29, 15, 46, 26, 36, 37, 50, 35, 29, 23, 31, 19, 68, 37, 34, 33, 49, 65, 43, 41, 52, 35, 37, 30, 30, 37, 30, 41, 58, 22, 36, 66, 43, 50, 49, 29, 39, 42, 70, 20, 30, 62, 41, 29, 29, 45, 38, 59, 46, 5, 31, 52, 44, 51, 60, 45, 33, 50, 40, 39, 46, 45, 63, 32, 53, 53, 43, 31, 34, 69, 36, 61, 18, 28, 26, 38, 31, 19, 55, 42, 53, 39, 62, 29, 55, 59, 22, 53, 29, 46, 39, 26, 26, 61, 38, 26, 50, 59, 53, 52, 42, 24, 25, 54, 15, 48, 43, 37, 31, 51, 26, 59, 37, 66, 68, 39, 39, 47, 28, 45, 42, 57, 41, 66, 21, 25, 58, 29, 40, 28, 27, 78, 39, 44, 27, 67, 63, 35, 63, 22, 49, 26, 44, 36, 34, 34, 38, 42, 44, 43, 41, 52, 7, 20, 51, 38, 50, 58, 35, 36, 27, 35, 48, 34, 67, 20, 48, 31, 40, 14, 65, 45, 75, 35, 32, 24, 46, 44, 30, 20, 50, 17, 38, 58, 60, 24, 53, 51, 56, 44, 65, 18, 52, 32, 35, 56, 37, 42, 48, 54, 48, 18, 22, 42, 32, 40, 39, 40, 41, 57, 53, 36, 26, 34, 26, 61, 42, 54, 50, 46, 56, 34, 43, 33, 41, 35, 20, 16, 32, 54, 50, 54, 60, 70, 24, 35, 47, 30, 13, 31, 46, 41, 36, 44, 48, 32, 33, 33, 56, 51, 39, 30, 46, 41, 54, 39, 48, 46, 43, 26, 34, 27, 43, 25, 57, 61, 62, 19, 47, 23, 27, 36, 48, 47, 58, 60, 23, 36, 31, 32, 10, 44, 46, 33, 49, 31, 67, 24, 40, 52, 15, 40, 44, 28, 48, 37, 40, 39, 45, 34, 50, 47, 29, 44, 20, 54, 35, 30, 51, 35, 44, 34, 54, 48, 35, 51, 28, 52, 36, 18, 40, 55, 19, 62, 58, 31, 22, 19, 32, 59, 42, 30, 32, 51, 67, 20, 38, 33, 94, 37, 59, 69, 61, 33, 35, 40, 43, 33, 28, 38, 48, 52, 43, 21, 55, 64, 38, 57, 47, 34, 39, 35, 40, 67, 34, 35, 64, 25, 21, 31, 41, 44, 24, 49, 54, 32, 23, 64, 64, 32, 37, 55, 45, 38, 45, 34, 35, 36, 35, 41, 29, 34, 55, 34, 45, 18, 48, 38, 24, 35, 45, 49, 34, 57, 34, 51, 57, 21, 47, 53, 64, 40, 54, 58, 14, 51, 63, 29, 56, 41, 64, 25, 21, 40, 75, 13, 50, 34, 45, 50, 65, 32, 42, 19, 41, 33, 18, 26, 35, 50, 40, 22, 34, 44, 55, 56, 10, 31, 13, 39, 20, 47, 12, 44, 52, 41, 43, 52, 31, 49, 35, 37, 58, 20, 17, 14, 38, 59, 27, 56, 21, 36, 54, 35, 26, 17, 26, 50, 32, 58, 37, 60, 57, 52, 42, 15, 54, 21, 18, 40, 48, 29, 38, 42, 48, 21, 46, 41, 48, 19, 20, 36, 21, 36, 49, 53, 16, 53, 22, 25, 62, 45, 23, 28, 30, 63, 44, 23, 37, 28, 22, 65, 43, 60, 21, 8, 25, 28, 52, 58, 46, 59, 4, 47, 64, 23, 35, 31, 33, 50, 45, 45, 24, 46, 51, 52, 68, 47, 19, 48, 63, 30, 38, 25, 41, 40, 59, 40, 23, 41, 27, 71, 30, 31, 73, 72, 52, 49, 30, 58, 53, 32, 72, 44, 45, 52, 43, 66, 43, 48, 17, 41, 27, 72, 24, 20, 63, 42, 36, 13, 41, 67, 40, 41, 34, 30, 39, 23, 38, 26, 46, 19, 26, 65, 46, 20, 31, 32, 49, 60, 58, 41, 9, 18, 29, 54, 34, 47, 51, 28, 44, 52, 44, 22, 56, 30, 52, 14, 41, 71, 50, 27, 15, 44, 25, 43, 39, 38, 58, 39, 51, 49, 27, 50, 52, 31, 17, 44, 45, 15, 42, 34, 51, 53, 55, 18, 66, 61, 22, 22, 36, 27, 64, 13, 76, 65, 36, 22, 30, 42, 57, 34, 52, 17, 58, 71, 39, 75, 24, 44, 18, 37, 64, 45, 23, 16, 22, 49, 46, 33, 46, 39, 41, 35, 30, 37, 25, 24, 47, 65, 20, 43, 55, 71, 27, 21, 55, 55, 48, 46, 8, 46, 46, 34, 19, 54, 58, 52, 42, 28, 13, 66, 33, 43, 21, 51, 55, 41, 43, 44, 48, 17, 22, 41, 39, 44, 53, 20, 32, 39, 64, 27, 50, 44, 43, 51, 34, 24, 26, 61, 42, 17, 45, 37, 60, 30, 22, 23, 44, 43, 33, 55, 29, 32, 31, 31, 51, 65, 80, 43, 57, 44, 29, 24, 12, 64, 42, 52, 24, 51, 22, 39, 42, 55, 33, 48, 47, 62, 31, 46, 14, 25, 55, 34, 21, 29, 47, 44, 21, 44, 58, 59, 24, 29, 38, 51, 39, 25, 44, 37, 62, 13, 48, 48, 39, 43, 12, 6, 52, 27, 47, 44, 34, 54, 42, 49, 38, 34, 35, 62, 35, 36, 49, 32, 19, 48, 61, 32, 57, 58, 27, 52, 44, 39, 26, 23, 42, 45, 56, 55, 52, 35, 38, 31, 31, 28, 20, 40, 48, 44, 40, 71, 63, 48, 44, 52, 47, 35, 63, 62, 25, 37, 35, 35, 39, 32, 43, 45, 58, 68, 25, 37, 50, 48, 30, 51, 31, 28, 52, 63, 50, 81, 36, 59, 48, 44, 27, 18, 19, 26, 54, 54, 39, 43, 24, 40, 13, 39, 22, 23, 29, 53, 34, 23, 61, 56, 43, 49, 48, 49, 42, 9, 27, 33, 39, 29, 26, 53, 46, 46, 43, 41, 28, 34, 29, 33, 43, 44, 15, 41, 30, 32, 55, 75, 50, 26, 55, 68, 15, 17, 22, 55, 33, 52, 23, 39, 39, 39, 74, 18, 21, 37, 36, 23, 64, 51, 20, 65, 38, 25, 68, 58, 33, 53, 27, 25, 59, 35, 49, 51, 28, 38, 40, 36, 27, 46, 24, 17, 47, 38, 64, 52, 18, 32, 20, 27, 48, 37, 46, 77, 10, 39, 33, 48, 29, 38, 37, 41, 81, 39, 19, 54, 46, 33, 60, 29, 52, 40, 14, 54, 38, 27, 34, 41, 37, 34, 57, 18, 23, 36, 31, 73, 39, 40, 33, 31, 22, 35, 36, 50, 28, 41, 31, 18, 38, 53, 27, 43, 33, 29, 34, 36, 48, 18, 39, 38, 27, 47, 51, 68, 44, 39, 16, 29, 54, 16, 42, 38, 43, 33, 25, 27, 56, 57, 57, 50, 59, 42, 46, 58, 48, 52, 37, 10, 25, 63, 18, 49, 26, 32, 23, 31, 47, 28, 11, 32, 54, 17, 66, 27, 31, 30, 50, 49, 36, 20, 32, 72, 30, 27, 14, 58, 40, 41, 51, 39, 48, 19, 49, 58, 58, 50, 54, 40, 29, 30, 33, 33, 44, 39, 39, 32, 37, 45, 38, 48, 28, 41, 40, 53, 52, 29, 38, 44, 57, 22, 39, 24, 45, 20, 38, 53, 43, 38, 54, 40, 35, 17, 53, 18, 34, 44, 18, 38, 55, 48, 46, 35, 26, 21, 34, 62, 53, 46, 30, 6, 18, 63, 56, 15, 58, 68, 47, 49, 47, 43, 26, 42, 31, 28, 42, 18, 35, 66, 45, 53, 67, 41, 31, 34, 48, 42, 57, 40, 47, 16, 67, 45, 61, 8, 12, 44, 74, 35, 41, 40, 37, 38, 46, 37, 56, 32, 57, 25, 51, 48, 47, 31, 60, 15, 64, 39, 46, 37, 38, 10, 48, 31, 62, 13, 26, 34, 33, 53, 61, 28, 67, 8, 33, 24, 32, 26, 66, 35, 52, 32, 43, 43, 27, 45, 34, 33, 35, 51, 33, 48, 39, 33, 40, 20, 30, 32, 34, 71, 62, 29, 54, 31, 24, 47, 11, 22, 18, 34, 41, 36, 65, 41, 35, 63, 27, 29, 44, 38, 13, 36, 23, 25, 40, 55, 47, 49, 46, 36, 53, 38, 16, 13, 28, 63, 28, 49, 15, 46, 12, 24, 50, 24, 49, 61, 79, 37, 21, 45, 33, 38, 38, 30, 49, 48, 52, 49, 45, 48, 9, 47, 49, 44, 49, 28, 28, 43, 10, 46, 52, 15, 51, 45, 54, 30, 10, 50, 25, 44, 25, 53, 50, 13, 65, 20, 66, 25, 39, 10, 40, 10, 38, 50, 36, 30, 51, 46, 53, 31, 41, 42, 35, 62, 51, 14, 33, 37, 57, 43, 56, 21, 22, 50, 41, 50, 27, 32, 11, 49, 56, 23, 54, 32, 46, 44, 29, 31, 25, 19, 50, 37, 46, 47, 48, 51, 20, 43, 57, 33, 44, 46, 70, 34, 45, 13, 36, 53, 28, 50, 10, 48, 27, 19, 52, 22, 51, 49, 65, 21, 40, 40, 18, 53, 27, 38, 37, 32, 74, 52, 23, 40, 54, 55, 51, 61, 34, 37, 43, 33, 33, 73, 48, 46, 48, 54, 49, 20, 33, 37, 43, 15, 36, 42, 40, 29, 43, 18, 31, 56, 36, 24, 57, 48, 67, 20, 16, 15, 62, 35, 53, 36, 43, 35, 35, 51, 62, 53, 66, 44, 34, 50, 34, 40, 58, 44, 52, 25, 30, 23, 52, 32, 50, 27, 28, 48, 30, 53, 50, 50, 35, 15, 22, 19, 45, 51, 22, 39, 36, 49, 61, 57, 58, 40, 43, 81, 79, 54, 41, 20, 22, 37, 12, 34, 61, 23, 37, 57, 36, 38, 43, 30, 60, 20, 45, 35, 32, 23, 27, 33, 30, 22, 24, 51, 23, 26, 35, 10, 70, 48, 38, 11, 24, 67, 32, 24, 62, 49, 24, 30, 49, 51, 31, 32, 14, 59, 50, 51, 30, 68, 38, 19, 37, 34, 46, 37, 63, 32, 21, 41, 43, 24, 41, 67, 26, 36, 46, 54, 61, 49, 35, 16, 16, 16, 56, 41, 41, 17, 40, 12, 46, 48, 19, 73, 31, 11, 52, 50, 26, 41, 55, 35, 23, 56, 22, 33, 60, 44, 23, 40, 23, 31, 43, 46, 26, 40, 40, 56, 29, 33, 24, 20, 53, 62, 22, 51, 68, 62, 56, 30, 56, 49, 64, 35, 39, 29, 36, 47, 24, 74, 36, 39, 54, 18, 21, 55, 34, 70, 24, 37, 31, 39, 63, 11, 42, 61, 31, 62, 46, 25, 38, 19, 53, 33, 26, 23, 52, 52, 36, 30, 10, 48, 58, 26, 29, 16, 23, 34, 22, 15, 26, 42, 15, 18, 46, 59, 58, 30, 42, 49, 16, 14, 50, 29, 27, 41, 48, 59, 42, 32, 33, 43, 43, 53, 52, 43, 63, 44, 19, 46, 43, 34, 50, 50, 23, 37, 36, 76, 50, 49, 54, 40, 35, 52, 42, 15, 32, 27, 22, 36, 26, 62, 31, 37, 50, 59, 35, 28, 18, 33, 39, 56, 44, 53, 39, 13, 12, 42, 44, 56, 58, 45, 31, 44, 74, 28, 46, 44, 31, 36, 40, 35, 41, 23, 34, 27, 27, 64, 39, 31, 51, 15, 38, 58, 41, 30, 31, 56, 44, 43, 41, 31, 10, 56, 66, 19, 54, 43, 35, 50, 40, 43, 50, 39, 19, 29, 17, 16, 46, 33, 11, 38, 47, 47, 33, 21, 45, 35, 37, 78, 69, 42, 59, 50, 30, 43, 50, 49, 29, 61, 46, 62, 25, 39, 67, 32, 43, 21, 26, 16, 26, 18, 55, 37, 33, 23, 33, 45, 47, 32, 51, 45, 23, 56, 49, 75, 28, 21, 34, 28, 40, 47, 34, 37, 43, 25, 31, 56, 65, 38, 14, 25, 33, 20, 7, 40, 39, 25, 56, 28, 51, 24, 52, 35, 46, 57, 52, 38, 56, 31, 18, 14, 20, 45, 36, 28, 24, 30, 50, 39, 43, 64, 31, 22, 48, 42, 42, 68, 51, 16, 37, 22, 43, 55, 22, 26, 41, 40, 29, 27, 35, 29, 59, 42, 50, 59, 31, 29, 52, 55, 30, 26, 30, 30, 39, 32, 40, 19, 45, 30, 32, 12, 52, 37, 26, 45, 36, 60, 58, 15, 9, 38, 38, 36, 44, 47, 27, 38, 46, 36, 44, 26, 28, 24, 32, 44, 14, 31, 62, 60, 61, 12, 45, 38, 55, 27, 30, 30, 70, 48, 38, 49, 33, 46, 47, 39, 43, 22, 29, 31, 37, 69, 14, 45, 81, 38, 45, 32, 13, 41, 7, 38, 44, 54, 45, 35, 13, 35, 53, 55, 25, 9, 15, 36, 40, 26, 35, 25, 45, 15, 55, 47, 22, 50, 29, 41, 35, 46, 25, 33, 23, 20, 35, 34, 31, 32, 29, 42, 46, 19, 60, 57, 31, 29, 31, 36, 50, 59, 51, 33, 31, 61, 64, 28, 58, 48, 43, 24, 33, 40, 43, 21, 48, 37, 44, 14, 31, 28, 41, 33, 50, 52, 59, 54, 50, 23, 47, 27, 28, 54, 44, 34, 28, 60, 46, 37, 29, 28, 54, 14, 26, 19, 41, 46, 31, 20, 74, 27, 31, 38, 48, 24, 48, 57, 72, 11, 43]}}\n\n def read_dataset_from_file(filename):\n with open(filename, 'rb') as file:\n dataset = pickle.load(file)\n\n transformed_dataset = {}\n\n for num_items, instances in dataset.items():\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"] = {}\n for instance_num, items in enumerate(instances, 1):\n instance_name = f\"test_{instance_num-1}\"\n instance_data = {\n \"capacity\": 100,\n \"num_items\": num_items,\n \"items\": items\n }\n transformed_dataset[f\"Weibull {int(num_items/1000)}k\"][instance_name] = instance_data\n\n return transformed_dataset\n \n # self.datasets = read_dataset_from_file('../weibull_instances/test_dataset_100k.pkl')\n # for test_num in range(5):\n # test_key = f'test_{test_num}'\n # data = np.array(self.datasets['Weibull 5k'][test_key]['items'])\n # print(data)\n # print(self.datasets['Weibull 5k'][test_key]['capacity'])\n # data = data / self.datasets['Weibull 5k'][test_key]['capacity']\n # self.datasets['Weibull 5k'][test_key]['capacity'] = 1.0\n # top_500_items = data[:1000]\n # self.datasets['Weibull 5k'][test_key]['items'] = top_500_items\n # self.datasets['Weibull 5k'][test_key]['num_items'] = 1000\n\n\n\n def l1_bound(self,items: tuple, capacity: int) -> float:\n \"\"\"Computes L1 lower bound on OPT for bin packing.\n\n Args:\n items: Tuple of items to pack into bins.\n capacity: Capacity of bins.\n\n Returns:\n Lower bound on number of bins required to pack items.\n \"\"\"\n return np.ceil(np.sum(items) / capacity)\n\n\n def l1_bound_dataset(self,instances: dict) -> float:\n \"\"\"Computes the mean L1 lower bound across a dataset of bin packing instances.\n\n Args:\n instances: Dictionary containing a set of bin packing instances.\n\n Returns:\n Average L1 lower bound on number of bins required to pack items.\n \"\"\"\n l1_bounds = []\n for name in instances:\n instance = instances[name]\n l1_bounds.append(self.l1_bound(instance['items'], instance['capacity']))\n return np.mean(l1_bounds)\n\n def get_instances(self):\n opt_num_bins = {}\n for name, dataset in self.datasets.items():\n opt_num_bins[name] = self.l1_bound_dataset(dataset)\n print(opt_num_bins)\n return self.datasets, opt_num_bins\n\n\n" }, { "path": "examples/user_bp_online/prob.py", "content": "import numpy as np\nimport importlib\nfrom get_instance import GetData\nfrom prompts import GetPrompts\nimport types\nimport warnings\nimport sys\n\nclass BPONLINE():\n def __init__(self):\n getdate = GetData()\n self.instances, self.lb = getdate.get_instances()\n self.prompts = GetPrompts()\n\n def get_valid_bin_indices(self,item: float, bins: np.ndarray) -> np.ndarray:\n \"\"\"Returns indices of bins in which item can fit.\"\"\"\n return np.nonzero((bins - item) >= 0)[0]\n\n\n def online_binpack(self,items: tuple, bins: np.ndarray, alg):\n \"\"\"Performs online binpacking of `items` into `bins`.\"\"\"\n # Track which items are added to each bin.\n packing = [[] for _ in bins]\n # Add items to bins.\n n = 1\n for item in items:\n # Extract bins that have sufficient space to fit item.\n valid_bin_indices = self.get_valid_bin_indices(item, bins)\n # Score each bin based on heuristic.\n priorities = alg.score(item, bins[valid_bin_indices])\n # Add item to bin with highest priority.\n best_bin = valid_bin_indices[np.argmax(priorities)]\n bins[best_bin] -= item\n packing[best_bin].append(item)\n n=n+1\n \n # Remove unused bins from packing.\n packing = [bin_items for bin_items in packing if bin_items]\n return packing, bins\n\n\n # @funsearch.run\n def evaluateGreedy(self,alg) -> float:\n # algorithm_module = importlib.import_module(\"ael_alg\")\n # alg = importlib.reload(algorithm_module) \n \"\"\"Evaluate heuristic function on a set of online binpacking instances.\"\"\"\n # List storing number of bins used for each instance.\n #num_bins = []\n # Perform online binpacking for each instance.\n # for name in instances:\n # #print(name)\n\n for name, dataset in self.instances.items():\n num_bins_list = []\n for _, instance in dataset.items():\n\n capacity = instance['capacity']\n items = np.array(instance['items'])\n\n # items = items/capacity\n # capacity = 1.0\n\n # Create num_items bins so there will always be space for all items,\n # regardless of packing order. Array has shape (num_items,).\n bins = np.array([capacity for _ in range(instance['num_items'])])\n # Pack items into bins and return remaining capacity in bins_packed, which\n # has shape (num_items,).\n _, bins_packed = self.online_binpack(items, bins, alg)\n # If remaining capacity in a bin is equal to initial capacity, then it is\n # unused. Count number of used bins.\n num_bins = (bins_packed != capacity).sum()\n\n num_bins_list.append(-num_bins)\n\n # avg_num_bins = -self.evaluateGreedy(dataset, algorithm)\n avg_num_bins = -np.mean(np.array(num_bins_list))\n fitness = (avg_num_bins - self.lb[name]) / self.lb[name]\n\n\n # Score of heuristic function is negative of average number of bins used\n # across instances (as we want to minimize number of bins).\n\n return fitness\n\n\n\n # def evaluate(self):\n # try:\n\n # for name, dataset in self.instances.items():\n # # Parallelize the loop\n # num_bins = Parallel(n_jobs=4,timeout=30)(delayed(self.evaluateGreedy)(instance) for _, instance in dataset.items())\n # # avg_num_bins = -self.evaluateGreedy(dataset, algorithm)\n # avg_num_bins = -np.mean(num_bins)\n # excess = (avg_num_bins - self.lb[name]) / self.lb[name]\n # #print(name)\n # #print(f'\\t Average number of bins: {avg_num_bins}')\n # #print(f'\\t Lower bound on optimum: {self.lb[name]}')\n # #print(f'\\t Excess: {100 * excess:.2f}%') \n # return excess\n # except Exception as e:\n # #print(\"Error:\", str(e)) # Print the error message\n # return None\n \n def evaluate(self, code_string):\n try:\n # Suppress warnings\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n\n # Create a new module object\n heuristic_module = types.ModuleType(\"heuristic_module\")\n \n # Execute the code string in the new module's namespace\n exec(code_string, heuristic_module.__dict__)\n\n # Add the module to sys.modules so it can be imported\n sys.modules[heuristic_module.__name__] = heuristic_module\n\n fitness = self.evaluateGreedy(heuristic_module)\n\n return fitness\n except Exception as e:\n #print(\"Error:\", str(e))\n return None\n\n\n\n\n" }, { "path": "examples/user_bp_online/prompts.py", "content": "class GetPrompts():\n def __init__(self):\n self.prompt_task = \"I need help designing a novel score function that scoring a set of bins to assign an item. \\\nIn each step, the item will be assigned to the bin with the maximum score. If the rest capacity of a bin equals the maximum capacity, it will not be used. The final goal is to minimize the number of used bins.\"\n self.prompt_func_name = \"score\"\n self.prompt_func_inputs = ['item', 'bins']\n self.prompt_func_outputs = ['scores']\n self.prompt_inout_inf = \"'item' and 'bins' are the size of current item and the rest capacities of feasible bins, which are larger than the item size. \\\nThe output named 'scores' is the scores for the bins for assignment. \"\n self.prompt_other_inf = \"Note that 'item' is of type int, while 'bins' and 'scores' are both Numpy arrays. The novel function should be sufficiently complex in order to achieve better performance. It is important to ensure self-consistency.\"\n#Include the following imports at the beginning of the code: 'import numpy as np', and 'from numba import jit'. Place '@jit(nopython=True)' just above the 'priority' function definition.\"\n\n def get_task(self):\n return self.prompt_task\n \n def get_func_name(self):\n return self.prompt_func_name\n \n def get_func_inputs(self):\n return self.prompt_func_inputs\n \n def get_func_outputs(self):\n return self.prompt_func_outputs\n \n def get_inout_inf(self):\n return self.prompt_inout_inf\n\n def get_other_inf(self):\n return self.prompt_other_inf\n\n" }, { "path": "examples/user_bp_online/runEoH.py", "content": "from eoh import eoh\nfrom eoh.utils.getParas import Paras\nfrom prob import BPONLINE\n\n# Parameter initilization #\nparas = Paras() \n\n# Set your local problem\nproblem_local = BPONLINE()\n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = problem_local, # Set local problem, else use default problems\n llm_api_endpoint = \"XXX\", # set your LLM endpoint\n llm_api_key = \"XXX\", # set your key\n llm_model = \"gpt-3.5-turbo\",\n ec_pop_size = 4, # number of samples in each population\n ec_n_pop = 4, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False,\n eva_numba_decorator = True)\n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j100_m10.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 1539989115 5770 5759\nprocessing times :\n 52 95 42 75 44 57 89 53 84 62 91 14 95 89 4 95 2 97 68 20 33 51 98 8 85 86 73 4 40 98 12 59 44 46 2 41 28 83 28 21 80 71 4 60 34 55 53 96 37 37 63 99 69 70 53 21 10 31 80 18 5 18 17 71 90 93 14 49 52 7 78 57 41 75 98 93 33 75 68 33 60 82 24 99 4 97 24 50 55 91 46 58 17 47 82 6 15 91 74 42\n 82 21 79 95 46 23 40 95 87 37 24 24 65 62 19 67 66 6 65 59 2 67 82 90 30 63 5 93 53 85 81 73 34 74 13 78 35 20 16 48 12 11 80 9 24 76 32 35 66 48 16 26 46 66 76 31 36 8 37 21 3 76 67 5 47 72 66 56 95 49 47 26 81 56 76 66 36 53 26 52 29 36 68 21 71 61 71 69 28 86 27 41 86 55 17 62 96 59 53 93\n 63 55 59 35 21 59 78 25 30 38 78 79 58 44 38 76 70 72 85 8 10 84 42 67 20 24 75 23 33 60 20 75 83 26 92 29 39 14 74 66 86 10 27 8 7 97 84 56 61 9 94 34 89 62 47 66 76 15 18 54 24 55 96 10 12 96 53 92 77 6 91 14 41 30 85 17 23 60 76 39 85 10 65 15 55 41 28 93 88 27 77 81 19 76 55 67 65 8 18 56\n 79 21 93 32 8 45 37 78 26 98 17 25 21 28 68 24 62 89 60 64 38 90 87 1 99 34 9 22 74 14 14 84 75 37 32 29 32 89 12 47 19 97 7 12 43 89 14 33 56 57 22 6 24 55 48 57 78 5 50 83 70 21 71 58 36 50 31 86 29 30 93 49 83 89 44 38 62 45 22 85 39 98 56 68 84 77 67 53 46 24 52 96 2 88 33 27 49 78 82 65\n 80 13 64 77 17 78 82 4 72 93 68 25 67 80 43 93 21 33 14 30 59 83 85 85 70 35 2 76 46 72 69 46 3 57 71 77 33 49 59 82 59 70 76 10 65 19 77 86 21 75 96 3 50 57 66 84 98 55 70 32 31 64 11 9 32 58 98 95 25 4 45 60 87 31 1 96 22 95 73 77 30 88 14 22 93 48 10 7 14 91 5 43 30 79 39 34 77 81 11 10\n 53 19 99 62 88 93 34 72 42 65 39 79 9 26 72 29 36 48 57 95 93 79 88 77 94 39 74 46 17 30 62 77 43 98 48 14 45 25 98 30 90 92 35 13 75 55 80 67 3 93 54 67 25 77 38 98 96 20 15 36 65 97 27 25 61 24 97 61 75 92 73 21 29 3 96 51 26 44 56 31 64 38 44 46 66 31 48 27 82 51 90 63 85 36 69 67 81 18 81 72\n 71 90 59 82 22 88 35 49 78 69 76 2 14 3 22 26 44 1 4 16 55 43 87 35 76 98 78 81 48 25 81 27 84 59 98 14 32 95 30 13 68 19 57 65 13 63 26 96 53 94 27 93 49 63 65 34 10 56 51 97 52 46 16 50 96 85 61 76 30 90 42 88 37 43 88 91 14 63 65 74 71 8 39 95 82 17 38 69 17 24 66 75 52 59 4 73 56 19 39 51\n 95 53 54 22 84 54 2 80 84 66 25 16 79 90 51 29 29 90 83 83 19 95 87 12 34 23 44 30 82 83 42 56 89 38 96 10 3 53 97 11 65 47 76 22 17 14 11 69 91 53 3 80 78 32 53 43 85 19 48 49 66 22 37 51 82 59 88 77 19 32 52 9 96 23 64 22 37 3 52 44 11 21 85 6 40 68 30 35 58 31 11 11 6 59 64 65 23 80 75 63\n 92 62 11 83 87 66 98 42 23 45 52 6 3 64 55 97 83 42 81 92 68 46 56 88 50 13 23 13 49 18 50 94 71 64 31 21 2 63 58 36 64 52 8 94 51 36 82 30 17 21 80 38 55 34 85 44 47 66 19 66 61 60 98 82 79 71 28 74 27 33 13 9 12 51 16 49 83 48 13 78 96 77 68 88 77 76 73 92 72 87 66 98 40 31 75 45 98 90 4 23\n 61 86 16 42 14 92 67 77 46 41 78 3 72 95 53 59 34 66 42 63 27 92 8 65 34 6 42 39 2 7 85 32 14 74 59 95 48 37 59 4 42 93 32 30 16 95 58 12 95 21 74 38 4 31 62 39 97 57 9 54 13 47 6 70 19 97 41 1 57 60 62 14 90 76 12 89 37 35 91 69 55 48 56 84 22 51 43 50 62 61 10 87 99 40 91 64 62 53 33 16\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 655816003 5349 5345\nprocessing times :\n 66 46 25 30 17 40 17 20 73 5 60 3 91 34 81 58 48 71 57 5 8 19 78 2 1 78 8 14 46 98 50 88 28 66 43 23 93 52 1 77 54 45 56 54 57 23 18 88 38 72 55 63 71 21 74 65 52 91 12 22 12 26 97 30 30 12 94 46 20 73 58 10 77 27 33 53 23 2 65 35 7 54 43 87 56 4 29 35 37 53 10 90 95 85 2 36 85 5 3 45\n 65 35 49 2 95 14 67 8 62 25 2 40 68 75 72 5 5 10 33 56 89 54 31 1 61 25 11 7 88 65 74 16 87 57 89 85 46 54 23 23 96 79 70 33 50 18 65 87 18 15 57 72 48 6 10 98 55 71 19 28 31 79 69 11 4 12 71 62 2 95 35 82 57 7 24 62 70 89 87 21 54 16 72 31 24 94 18 83 36 73 67 74 75 93 16 74 70 16 81 93\n 58 66 5 69 38 93 59 56 26 96 60 18 74 93 12 56 36 71 38 96 84 84 65 17 78 45 83 53 60 60 9 7 51 85 66 6 3 93 88 40 85 92 15 51 55 19 58 84 4 23 38 23 13 1 10 76 49 2 81 43 51 71 29 44 26 27 27 56 21 76 88 9 33 6 40 64 5 5 7 5 76 63 35 94 65 25 6 87 60 33 67 81 93 98 9 94 49 27 62 90\n 5 13 36 54 76 40 67 31 35 48 85 41 82 95 15 24 77 6 79 36 18 21 34 42 74 46 1 88 29 95 67 41 98 31 25 70 62 45 59 68 22 81 44 80 88 25 93 61 1 97 26 40 84 84 74 39 65 15 71 92 44 27 93 2 55 44 55 23 25 1 51 12 47 98 41 18 44 72 88 60 29 99 2 17 79 6 29 89 4 70 10 79 64 92 42 79 56 94 26 93\n 66 41 74 62 70 30 66 11 51 43 32 23 20 1 54 55 65 22 99 97 21 63 45 70 41 6 70 33 97 32 28 54 63 16 12 2 50 48 34 75 45 2 39 4 46 11 66 59 28 74 93 95 48 71 30 22 3 22 82 35 56 14 88 41 4 52 17 95 15 85 12 11 24 71 46 59 16 33 53 22 49 44 76 88 45 52 31 66 17 68 99 78 87 45 78 51 87 4 45 9\n 39 12 45 34 11 71 53 28 93 61 61 78 13 49 15 31 93 83 20 1 13 36 6 22 44 65 87 50 96 51 48 89 69 83 22 26 29 67 70 59 34 18 4 65 58 35 86 34 49 88 42 79 25 18 75 45 54 19 80 15 22 56 63 56 79 82 92 19 45 32 11 59 22 14 88 82 82 71 8 13 53 71 98 99 54 20 62 18 81 60 1 93 8 92 60 87 11 24 11 98\n 40 62 8 13 87 40 27 44 41 70 10 94 25 10 36 87 37 86 76 70 17 92 90 58 19 97 80 28 67 59 9 92 7 19 82 60 60 58 74 70 72 33 71 68 94 82 46 78 37 69 7 34 69 18 98 8 58 86 77 50 50 82 16 17 68 65 92 37 47 70 66 30 7 37 5 52 86 36 29 4 99 53 52 9 8 50 62 14 21 88 7 85 62 10 61 92 47 77 37 96\n 50 4 20 19 58 22 56 92 59 34 17 39 59 7 59 2 70 72 90 56 26 50 4 8 60 60 80 38 51 25 97 73 46 82 92 42 65 12 34 23 99 48 41 40 76 89 42 90 61 25 27 60 79 50 15 65 80 67 70 94 61 55 2 55 78 27 13 20 38 75 23 61 37 43 69 2 44 25 12 31 1 54 94 63 91 27 55 74 77 77 81 29 91 20 99 27 30 85 5 4\n 64 44 58 7 69 12 5 69 46 23 95 24 58 88 46 65 31 84 4 73 43 97 49 2 54 12 31 52 29 98 46 83 78 52 63 66 45 49 21 13 9 87 3 15 55 5 8 94 60 18 20 65 50 76 75 7 82 49 3 56 38 85 29 26 23 28 19 10 72 33 21 79 55 69 38 15 58 36 11 98 2 74 16 21 10 98 74 84 55 19 20 37 90 76 10 81 27 52 21 1\n 79 18 99 75 47 96 6 22 3 29 12 53 42 61 49 56 9 6 54 57 16 95 26 25 71 50 38 15 85 20 25 67 7 12 50 8 82 5 9 41 85 77 74 17 38 42 20 68 93 15 28 91 32 56 70 51 9 94 63 33 89 6 41 22 68 83 79 69 44 64 77 46 76 64 25 55 30 89 96 71 69 88 24 41 53 8 58 19 50 21 43 18 74 50 20 81 98 92 21 83\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 960914243 5677 5623\nprocessing times :\n 47 12 19 32 63 78 77 51 59 54 48 96 52 42 57 30 34 77 80 7 11 2 91 99 5 43 39 64 8 26 71 32 73 26 91 92 55 51 11 22 75 49 95 88 6 19 99 73 27 50 25 33 94 35 63 44 80 7 72 95 40 48 41 15 18 31 68 99 79 78 95 37 37 50 79 30 2 30 78 99 42 99 16 58 35 84 84 35 20 4 9 44 35 5 68 43 69 9 78 57\n 94 93 53 63 41 81 74 37 52 24 45 19 72 62 78 83 98 83 58 61 47 16 28 48 63 74 45 36 29 38 66 62 96 22 95 81 92 20 51 71 30 23 77 20 1 96 32 13 8 36 18 64 58 1 72 10 20 6 40 91 56 39 68 50 93 71 79 57 5 95 41 12 84 81 88 32 94 37 31 25 92 74 49 10 76 11 44 32 89 56 69 76 65 47 53 39 41 89 39 20\n 56 31 66 73 96 31 41 79 66 49 39 28 24 85 64 37 85 40 35 77 30 26 41 6 19 83 52 54 71 86 45 78 61 5 87 43 44 42 30 12 7 18 80 53 6 81 29 22 49 1 79 56 15 36 48 31 57 49 20 67 20 34 78 27 40 46 23 28 84 33 87 76 18 3 77 50 96 75 91 12 34 51 54 37 82 69 49 19 69 48 96 13 4 28 74 7 24 98 30 97\n 59 94 87 22 59 30 2 55 36 73 98 15 54 55 3 54 89 50 68 9 81 42 11 12 55 75 10 91 87 5 44 56 18 89 51 94 11 56 37 85 55 33 9 20 26 80 98 88 55 78 53 46 3 56 46 34 27 21 81 14 52 50 80 48 22 10 56 18 67 63 47 43 71 4 29 99 6 19 56 96 44 94 83 30 65 61 21 76 8 99 68 42 38 44 7 3 61 10 84 78\n 74 26 84 41 3 46 39 90 62 63 74 4 37 75 72 30 43 95 41 97 70 92 36 70 37 36 42 34 29 80 91 56 71 14 31 75 80 73 32 56 84 20 64 44 69 63 94 86 66 97 25 90 12 62 83 32 12 38 22 92 63 61 46 6 83 49 78 84 97 56 76 9 38 21 80 47 24 95 80 65 72 91 21 70 12 67 65 90 47 82 62 3 84 30 91 5 11 41 14 28\n 78 58 53 17 36 3 83 91 73 81 74 2 31 37 78 74 51 41 78 26 33 70 10 45 70 2 92 50 54 64 44 4 99 43 43 11 60 53 45 63 87 20 71 95 71 99 79 19 41 74 8 55 87 87 37 52 36 6 42 30 3 86 3 89 57 27 28 88 48 26 58 6 33 3 25 61 93 69 53 47 28 36 39 63 66 44 18 67 17 84 9 33 80 27 42 60 96 81 31 88\n 17 60 51 61 26 60 80 45 20 62 55 25 68 56 5 14 20 19 92 88 23 78 35 94 31 67 10 15 32 94 15 53 42 45 39 84 64 27 10 22 14 8 70 91 23 35 6 52 93 26 89 49 89 60 6 60 24 70 42 86 64 47 19 17 30 79 53 71 77 95 73 97 32 25 85 79 17 31 78 31 21 5 34 96 95 63 4 60 35 6 75 41 61 11 74 52 60 43 50 66\n 74 71 89 81 59 62 64 62 67 68 87 47 60 10 76 46 56 48 61 13 13 38 37 11 12 63 97 26 27 89 74 80 83 49 79 49 44 30 30 53 46 26 31 1 43 27 91 70 89 68 2 82 72 29 12 37 46 50 93 77 6 77 7 63 21 85 67 77 95 52 97 79 21 20 7 54 71 79 22 77 59 11 69 85 7 85 42 44 74 69 68 64 37 4 89 96 92 74 33 90\n 12 5 15 16 64 6 65 53 19 93 21 38 54 46 33 38 32 12 90 46 8 78 95 28 47 10 16 45 18 4 98 35 85 77 4 33 87 47 5 81 25 31 83 45 23 30 89 40 92 48 63 63 76 90 1 24 1 77 91 78 93 32 97 85 91 40 67 84 31 5 89 59 69 68 46 4 90 76 97 33 23 46 36 70 98 45 49 50 52 67 6 58 71 53 36 80 8 27 21 66\n 98 97 69 24 10 7 79 84 50 86 24 28 73 72 19 20 8 20 45 59 51 54 58 16 38 94 72 69 14 83 86 58 61 77 63 67 1 59 18 26 45 82 78 43 61 2 70 52 99 60 97 1 76 8 15 69 5 31 39 34 9 81 34 16 14 13 36 73 6 43 29 68 59 76 86 43 12 18 55 21 9 47 17 49 28 12 84 12 62 15 7 26 58 30 5 7 40 50 30 64\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 1915696806 5791 5732\nprocessing times :\n 95 61 33 79 6 89 3 81 98 35 94 95 44 71 50 51 43 73 52 92 82 52 53 14 49 21 49 46 22 18 41 17 69 31 26 62 85 96 10 62 11 4 59 86 70 80 3 46 30 90 79 35 15 91 37 2 70 4 31 84 53 2 71 39 66 66 42 92 49 83 23 2 81 87 9 42 6 63 79 19 5 62 65 57 13 89 56 46 52 60 79 44 52 98 4 64 95 22 24 29\n 84 31 71 84 12 26 34 69 65 90 43 30 74 4 66 22 65 46 36 98 31 65 97 25 46 89 79 44 74 93 43 4 45 48 61 93 76 22 54 7 43 26 40 42 80 38 19 32 70 83 63 42 60 79 60 10 98 56 88 20 77 42 45 98 35 6 93 61 35 67 71 82 49 2 73 61 11 33 99 93 64 58 62 91 43 1 95 50 69 9 58 2 2 55 39 48 5 56 84 92\n 64 16 99 70 73 23 15 83 57 80 90 8 23 44 21 94 88 37 16 3 31 73 8 14 99 67 67 14 57 99 47 82 27 91 38 60 73 91 47 13 96 92 32 90 74 6 96 91 66 80 98 38 20 31 13 47 89 67 22 30 8 70 55 67 51 88 34 91 82 97 36 42 92 40 85 6 31 92 41 63 21 54 69 46 10 28 97 66 72 14 88 14 53 65 98 25 62 75 53 78\n 5 22 41 94 11 62 32 14 87 76 33 72 96 24 26 96 3 70 70 47 53 2 49 36 25 66 89 58 98 31 91 8 18 83 67 97 61 18 7 53 65 25 80 7 88 61 32 36 53 56 46 64 27 26 22 48 58 18 23 66 64 88 27 19 57 69 55 29 65 38 91 90 52 89 68 12 75 13 21 20 62 95 10 46 88 53 35 75 30 20 92 25 16 66 15 29 84 1 39 25\n 76 20 55 51 39 92 83 62 56 59 47 33 31 61 74 73 43 52 23 42 49 66 27 40 53 50 63 61 65 9 30 27 45 58 38 75 45 6 38 56 46 93 63 66 98 20 56 79 21 78 41 8 49 79 92 58 66 62 68 6 5 45 47 27 46 83 56 45 60 12 70 51 99 57 12 56 77 23 41 26 63 39 28 3 35 55 33 72 23 37 14 90 60 16 27 49 21 76 54 78\n 73 9 6 84 56 50 65 74 80 25 26 14 95 63 83 42 97 94 64 69 84 28 67 19 75 70 50 28 83 26 67 82 97 39 74 55 22 1 68 53 76 63 43 81 67 33 51 37 72 8 93 98 93 53 68 12 68 83 94 54 5 36 37 56 94 91 85 3 60 52 22 63 96 9 58 5 6 68 49 10 4 50 2 72 40 76 14 74 22 66 78 94 43 36 58 78 20 98 2 53\n 58 34 82 99 45 7 43 22 4 71 85 3 88 1 75 85 34 95 26 24 68 87 20 17 91 40 63 76 15 72 69 40 56 82 41 10 91 91 89 93 94 93 97 95 80 33 95 75 59 33 40 79 45 92 17 41 77 88 35 58 20 14 82 9 7 62 91 60 76 24 77 47 56 22 11 6 7 86 23 64 32 58 45 78 17 60 29 71 18 6 67 61 92 75 12 91 10 7 84 2\n 54 11 63 98 17 83 70 34 45 54 59 84 25 51 18 28 73 50 4 83 31 4 41 12 94 37 92 10 59 35 33 94 36 56 15 68 43 46 31 2 17 50 18 40 12 13 60 76 82 71 27 95 63 71 52 98 15 47 83 83 69 64 43 32 28 94 86 16 39 67 60 35 70 75 60 75 65 53 89 46 28 93 86 93 1 40 68 79 97 31 85 92 53 21 39 85 40 58 95 90\n 3 96 28 90 86 29 83 39 62 69 38 43 39 77 46 47 72 23 80 23 87 69 33 11 77 29 28 29 11 4 95 76 69 44 94 99 6 56 16 97 46 18 33 49 76 20 61 95 92 72 47 54 85 81 19 82 96 18 32 71 6 3 43 85 81 77 22 19 49 96 73 41 98 96 77 44 80 34 7 69 57 54 15 54 45 88 92 88 59 89 48 63 92 17 5 88 58 3 79 46\n 76 92 56 65 93 50 3 82 59 15 44 53 6 75 28 56 49 72 88 94 85 42 62 56 75 36 46 92 55 87 45 9 19 76 50 32 63 33 27 95 29 91 96 27 95 39 84 96 42 8 92 16 80 35 51 15 51 76 75 35 69 45 27 10 9 27 16 52 29 33 85 43 1 42 75 80 12 91 43 53 83 29 71 59 2 98 85 26 73 52 87 76 93 70 25 40 45 49 64 93\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 2013025619 5468 5431\nprocessing times :\n 68 40 43 72 87 59 67 89 84 43 92 90 23 20 97 57 33 7 69 56 16 41 7 74 54 67 15 85 83 42 29 64 3 9 35 24 72 70 47 78 60 11 60 5 24 52 39 14 65 99 69 96 54 37 35 19 10 88 61 95 18 49 69 86 28 6 40 88 94 78 43 31 54 80 11 27 3 32 2 49 27 81 18 83 84 49 64 20 52 42 51 66 95 18 37 70 22 87 67 15\n 1 37 91 59 2 44 29 37 30 20 19 79 41 79 49 21 97 86 15 57 76 14 57 80 93 31 66 30 82 11 71 94 35 71 76 76 26 31 58 31 98 26 92 11 72 46 20 38 57 5 19 65 35 89 41 15 99 19 74 63 92 29 47 80 7 43 89 9 99 38 76 52 48 55 17 63 92 77 31 44 76 18 7 40 47 73 41 70 86 8 63 77 91 24 19 63 72 17 46 66\n 10 76 75 29 10 86 62 26 1 62 89 2 62 96 99 91 85 42 7 4 23 74 83 41 63 99 55 37 23 1 84 46 31 93 79 32 71 60 42 24 51 98 64 85 31 11 95 58 57 28 76 40 96 54 91 90 41 72 37 38 64 98 36 20 3 41 93 44 3 19 66 55 66 68 1 5 59 64 1 5 11 46 10 56 25 95 12 48 11 45 25 62 12 67 17 59 30 73 34 27\n 50 87 77 88 80 75 41 84 24 27 52 73 75 23 52 97 40 50 95 34 2 76 26 48 16 20 86 62 54 50 26 4 4 59 24 14 49 35 78 77 72 10 87 24 26 46 40 86 40 8 39 11 96 74 22 22 50 6 95 83 70 1 8 94 65 70 61 80 82 23 51 92 25 23 40 69 42 13 17 27 74 7 25 73 81 84 40 28 86 17 66 33 20 84 23 73 25 87 2 15\n 77 30 88 21 29 12 2 95 24 20 66 82 45 4 22 81 56 85 3 82 94 72 96 55 3 63 65 20 4 95 20 57 38 46 76 10 79 7 12 60 85 73 18 75 77 71 83 63 52 66 30 71 57 83 34 31 11 50 22 7 82 34 5 62 3 68 35 79 10 60 67 10 87 25 24 4 36 44 22 8 49 97 8 9 18 34 54 42 70 59 8 29 6 42 33 67 7 64 7 60\n 79 26 57 98 27 66 89 90 44 91 36 66 71 32 80 25 32 39 38 5 97 56 65 14 58 35 97 24 46 91 53 29 72 43 62 27 57 14 92 69 61 8 78 43 53 2 72 23 85 49 6 34 6 51 17 66 31 58 84 70 87 99 88 60 4 2 99 79 49 53 16 64 72 59 62 66 92 28 72 50 80 48 12 32 76 33 65 18 88 60 67 54 61 72 50 42 30 24 27 6\n 68 48 56 54 38 65 56 29 21 99 34 25 66 54 1 52 23 50 61 36 60 1 57 38 68 45 85 13 55 98 12 97 6 94 43 86 2 84 94 28 68 45 43 89 86 8 32 62 11 36 3 23 79 99 57 4 69 69 30 99 51 66 33 13 89 73 26 25 88 70 72 56 1 6 97 57 64 40 4 71 84 50 1 30 84 33 69 19 37 25 27 71 55 19 43 80 93 76 52 26\n 70 36 23 72 23 28 14 48 54 86 81 12 26 76 41 89 70 54 6 65 7 14 88 98 57 19 72 41 40 62 47 65 14 99 65 14 99 65 62 30 6 80 52 35 25 54 44 40 99 21 74 10 46 99 88 91 57 85 62 46 88 11 27 35 50 68 58 47 44 37 76 30 98 57 7 15 84 39 62 1 41 59 92 51 82 49 78 87 60 55 57 70 11 62 53 95 97 9 85 17\n 26 97 5 89 77 47 60 12 96 63 27 87 46 10 97 59 58 73 11 31 41 23 36 54 7 31 90 83 65 61 15 10 61 55 81 87 81 50 43 67 54 79 26 64 83 56 8 78 27 1 97 35 29 22 16 87 79 82 65 62 99 22 79 37 31 30 40 93 22 91 8 44 95 93 83 38 74 24 50 75 60 15 73 68 63 79 40 2 45 94 3 16 29 55 3 72 87 64 33 64\n 64 32 23 94 93 69 75 65 68 93 4 91 15 83 38 34 67 24 78 41 87 55 83 5 34 16 57 66 23 13 35 8 17 20 18 66 10 48 71 64 97 59 25 67 5 15 33 6 27 34 12 28 15 36 22 82 43 97 6 28 65 45 73 63 41 12 11 85 82 41 87 84 25 59 89 86 15 17 44 71 15 10 68 58 33 14 3 89 94 19 33 55 55 37 26 22 75 4 82 30\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 1168140026 5303 5246\nprocessing times :\n 30 26 71 3 56 61 21 2 18 76 77 37 2 9 75 61 96 44 24 8 6 8 90 15 48 95 88 62 53 23 60 89 84 28 79 45 14 72 31 32 25 88 35 66 85 20 3 18 66 74 75 39 14 58 27 42 44 91 49 16 80 39 83 19 39 64 59 19 59 63 72 77 39 44 25 4 73 4 3 27 64 12 97 43 7 54 29 72 75 76 36 74 96 88 66 62 3 25 40 4\n 98 1 11 71 3 59 80 50 33 22 97 69 91 64 44 85 94 8 26 8 23 8 93 36 5 66 69 73 63 47 14 38 40 86 3 39 68 32 26 83 7 37 81 66 67 12 50 55 8 35 81 72 5 6 37 75 53 57 16 29 98 82 33 25 12 55 17 15 93 2 56 28 49 75 81 62 25 1 91 70 49 47 93 21 77 6 93 68 98 12 72 16 20 92 31 17 24 43 7 92\n 75 92 78 26 54 3 46 29 39 10 65 74 97 31 35 53 57 27 1 11 33 41 78 42 20 86 60 42 42 59 53 55 43 70 99 9 20 26 72 20 32 21 28 23 2 37 23 77 86 13 94 2 22 18 10 43 25 46 3 20 88 56 58 43 37 19 16 4 8 25 68 12 73 73 47 43 16 13 42 42 78 47 45 45 21 28 87 24 85 35 83 34 54 35 43 28 4 39 98 72\n 45 57 14 59 10 18 87 40 21 59 92 12 88 51 49 85 93 60 20 41 94 46 5 20 89 43 88 47 86 13 54 46 84 73 10 92 73 19 41 44 39 83 24 85 14 31 62 60 1 80 92 11 47 41 91 82 1 4 71 89 89 82 38 58 92 34 77 81 92 27 5 11 98 11 27 13 48 77 52 58 50 98 61 20 17 23 58 76 51 5 63 33 86 16 57 14 78 69 66 27\n 56 59 22 2 46 4 31 90 2 75 25 58 59 39 27 97 84 40 22 29 95 70 25 92 45 57 26 47 12 96 67 1 79 23 33 11 77 4 56 12 86 10 48 56 10 52 1 30 41 68 34 60 48 61 83 76 32 17 61 84 25 50 62 32 54 40 3 43 17 49 36 89 61 67 93 53 55 60 21 59 38 98 79 98 83 3 70 3 47 49 60 73 8 37 43 36 47 80 7 66\n 56 76 27 87 7 68 9 8 45 54 23 13 91 82 25 92 21 35 81 51 48 47 34 19 82 57 72 19 38 70 96 38 41 90 18 15 25 61 54 27 15 66 27 5 48 67 22 46 56 41 22 70 13 12 30 46 6 81 59 28 96 82 38 40 42 58 86 72 45 98 71 77 91 78 41 52 45 39 3 11 17 91 10 53 71 55 7 27 35 18 82 37 89 60 25 60 28 17 91 94\n 63 47 36 26 80 14 50 44 43 94 72 89 22 16 2 23 92 25 63 90 98 74 23 4 30 8 76 28 79 47 92 19 17 15 76 68 74 13 12 84 33 32 24 37 7 12 24 56 10 16 97 38 70 60 31 5 1 37 86 27 49 27 2 36 24 99 55 31 63 34 86 35 11 32 20 15 14 5 30 61 60 47 1 94 82 72 85 89 96 79 12 17 60 16 24 97 95 5 35 92\n 94 73 7 25 9 31 13 54 11 81 25 61 34 98 53 26 91 43 23 29 38 51 13 97 94 27 90 2 14 36 48 71 25 1 58 64 47 2 29 18 52 6 32 54 6 47 55 60 88 65 31 94 78 84 88 80 6 5 3 62 48 97 93 34 23 76 33 84 77 80 59 57 91 4 54 31 2 21 58 90 91 41 65 87 87 91 46 40 95 95 44 13 61 67 37 82 84 75 9 4\n 63 77 44 15 45 82 54 59 10 21 40 30 23 73 94 4 47 63 42 29 20 43 93 1 59 23 59 12 11 47 62 54 42 5 64 24 39 30 76 20 35 45 42 7 23 40 59 28 68 84 38 14 55 22 88 57 86 84 22 39 48 84 91 55 23 42 10 63 78 56 9 40 99 34 40 44 18 79 28 44 12 6 68 66 29 43 13 89 61 8 90 82 88 16 63 70 72 93 97 3\n 72 52 40 79 70 53 32 47 70 38 76 19 46 52 60 49 60 1 19 12 76 12 65 22 7 26 40 34 99 95 76 7 25 55 96 42 44 42 21 15 99 41 55 17 20 55 72 57 81 57 84 89 66 89 59 17 98 22 3 75 41 63 5 69 12 14 93 86 93 14 88 28 56 60 8 70 88 29 33 91 78 2 46 42 89 5 51 76 57 78 31 5 19 95 37 6 38 36 39 36\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 1923497586 5599 5523\nprocessing times :\n 1 96 21 57 7 34 72 12 80 99 28 80 30 15 95 19 12 59 66 51 6 36 74 53 25 68 37 42 68 74 93 39 75 54 10 60 15 75 71 22 10 65 39 99 77 39 50 14 75 28 92 74 20 70 43 6 77 25 68 83 28 13 74 18 71 11 17 27 89 14 13 40 97 70 96 13 66 77 2 41 69 34 10 91 98 60 3 86 55 95 73 65 24 22 5 67 39 58 4 30\n 95 75 24 3 83 67 88 75 28 65 54 65 34 17 51 98 94 22 57 37 90 38 20 85 49 37 29 84 93 99 44 39 18 40 24 98 61 72 21 76 87 32 8 17 54 43 3 65 33 36 70 18 19 76 7 34 66 72 16 95 80 10 63 14 89 65 43 44 28 39 59 91 70 24 96 1 92 79 57 88 60 70 38 94 94 30 50 17 43 28 33 48 48 81 50 86 23 95 3 80\n 17 74 87 39 14 28 12 49 88 91 53 40 1 55 39 35 99 17 69 67 13 98 79 20 57 68 17 27 25 36 67 73 34 47 65 79 31 54 56 33 66 30 89 45 44 91 18 67 94 41 78 27 15 55 28 28 26 98 98 77 79 12 96 78 29 28 14 52 27 51 46 98 97 38 78 89 67 91 51 62 79 93 25 61 59 20 92 1 35 97 79 37 72 76 89 7 79 85 40 24\n 6 73 64 30 30 99 61 26 38 46 76 65 51 39 23 71 63 94 62 87 43 45 46 9 10 42 43 46 7 15 32 80 4 73 42 98 24 25 13 38 3 69 38 61 8 54 90 3 5 25 31 38 36 35 52 13 78 31 8 62 36 98 7 3 5 82 41 2 63 56 85 85 25 98 58 16 99 61 21 26 67 96 70 89 5 45 38 79 73 99 33 1 84 79 44 39 16 50 39 55\n 24 83 59 58 60 15 15 27 47 25 43 11 20 36 3 42 51 11 86 55 20 3 64 19 49 70 28 53 96 52 44 24 40 66 2 89 70 69 3 77 96 40 66 75 81 52 78 86 44 85 79 28 43 20 16 9 80 36 14 86 70 87 77 44 52 86 12 49 68 56 59 87 82 5 23 6 15 42 63 66 59 98 67 73 94 27 56 96 81 92 68 92 77 94 93 28 75 74 34 80\n 3 65 73 81 38 71 3 40 6 98 4 23 23 2 66 67 8 76 58 82 63 18 17 5 75 52 95 55 62 84 5 33 72 52 8 74 70 5 38 7 86 41 99 98 2 51 13 96 78 49 59 42 18 51 95 82 96 45 25 80 42 66 41 1 14 66 89 35 2 63 80 34 45 42 81 27 15 42 80 11 4 84 25 45 42 61 4 34 54 46 80 1 94 8 56 52 13 39 62 84\n 53 7 27 44 36 21 53 38 37 90 34 1 83 64 69 30 18 74 9 70 41 5 70 5 4 65 53 17 6 98 84 39 3 9 50 58 87 54 41 87 9 49 93 70 4 13 60 41 48 75 86 28 67 29 53 24 95 66 32 66 61 18 99 48 31 66 15 93 64 77 67 74 90 44 51 17 50 80 44 63 19 24 24 35 79 62 11 59 14 89 16 96 72 95 92 34 64 83 66 6\n 71 54 48 16 22 14 39 99 68 32 20 7 26 2 58 92 86 45 19 90 54 51 88 72 44 85 20 5 10 98 44 6 44 12 55 14 66 28 80 64 13 73 44 11 89 78 6 10 44 28 77 33 22 77 90 23 10 44 1 53 58 40 48 94 20 34 16 99 27 80 24 19 34 6 65 11 14 97 14 77 58 86 72 20 22 2 28 16 54 19 77 7 27 19 80 80 40 49 46 85\n 55 56 21 77 83 43 11 64 59 37 96 27 9 63 82 31 27 67 82 65 74 41 10 36 69 1 21 72 37 54 88 65 97 71 13 90 88 39 46 89 99 82 14 14 63 67 16 46 28 91 69 34 9 7 43 62 29 70 28 62 34 67 16 83 64 32 43 67 37 79 31 41 3 11 71 21 26 98 39 73 59 33 71 49 22 6 68 14 36 17 30 83 94 53 30 74 24 47 76 28\n 20 35 25 81 19 4 42 58 18 19 73 14 44 13 11 55 91 51 42 47 94 43 68 77 42 75 17 85 54 83 30 52 89 54 74 86 27 22 24 11 12 8 15 21 75 84 29 15 26 83 38 32 13 10 23 28 42 68 78 39 76 4 45 25 23 77 3 20 49 35 29 59 14 94 11 17 80 70 20 25 12 78 58 13 22 53 92 7 62 94 8 81 5 24 98 85 75 57 37 96\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 167698528 5623 5556\nprocessing times :\n 47 45 28 99 48 24 89 73 34 78 88 2 36 5 50 70 78 50 25 84 38 93 4 56 98 36 80 41 79 54 28 30 70 9 53 56 59 6 74 30 47 68 45 59 95 58 46 18 99 33 96 77 52 46 19 41 97 90 29 58 93 79 32 62 84 93 10 91 61 36 75 76 5 88 14 18 14 35 82 75 70 95 15 60 93 49 33 33 11 25 85 17 40 33 67 35 64 53 12 57\n 79 92 92 45 88 30 28 95 65 20 16 8 1 46 38 54 36 87 53 82 52 19 66 42 41 87 52 81 63 86 39 80 20 11 89 31 53 49 37 41 27 83 79 89 36 81 91 22 25 83 60 38 65 29 38 25 52 81 10 29 5 7 19 94 15 52 36 4 32 9 62 17 7 42 27 36 37 19 60 34 57 60 48 51 22 18 68 23 94 30 80 50 16 24 74 61 2 59 7 82\n 94 35 24 29 32 39 73 27 48 18 57 76 44 80 29 12 18 2 24 2 13 11 52 52 2 10 41 40 34 1 2 46 39 43 17 85 14 11 84 46 16 58 53 72 20 79 19 12 76 5 75 99 73 20 70 28 13 89 16 64 92 69 15 81 31 22 37 95 42 65 79 8 46 95 95 59 75 62 56 66 68 58 18 97 94 26 25 86 38 44 73 65 75 4 81 66 27 32 47 69\n 69 92 13 93 5 35 76 29 47 18 56 5 34 25 7 57 57 79 54 89 91 7 52 44 36 51 40 5 93 54 43 48 62 77 19 49 9 83 42 82 37 28 12 8 46 75 47 33 77 5 55 28 72 83 82 86 38 51 91 96 54 38 55 71 3 41 48 30 30 2 16 6 57 2 78 15 73 26 96 8 4 79 84 88 36 70 81 92 96 82 19 86 50 12 71 28 41 11 95 42\n 8 9 34 15 30 83 15 98 15 40 63 81 72 4 44 82 86 37 26 63 60 69 5 73 74 89 23 80 94 4 23 53 38 53 70 25 97 76 12 83 47 84 77 78 24 67 39 1 18 68 68 11 48 38 38 23 68 75 89 58 57 86 24 54 81 13 49 81 74 23 42 95 43 9 88 23 28 86 88 6 64 49 85 53 34 86 39 90 33 22 11 4 33 95 74 17 67 82 31 34\n 15 88 56 27 75 61 69 87 53 40 4 50 97 19 75 57 13 72 63 36 60 52 92 88 59 33 74 17 28 95 25 57 59 83 35 78 92 3 7 66 12 54 68 39 83 59 20 76 88 90 24 80 44 95 45 12 84 27 1 95 77 14 74 56 76 79 92 35 40 40 23 36 82 58 35 67 96 21 9 79 8 62 66 59 19 77 35 48 63 52 66 26 91 60 24 6 7 23 75 4\n 40 62 38 14 55 89 3 29 53 63 1 72 25 32 85 99 25 75 44 33 37 52 99 37 85 81 91 46 81 46 77 95 13 18 60 44 84 80 30 11 29 75 49 50 38 56 11 58 18 33 67 84 1 45 25 47 31 99 28 59 36 70 77 54 44 32 35 24 13 17 21 97 23 67 38 81 31 54 41 28 38 51 77 6 2 4 89 82 39 16 42 36 1 75 14 22 69 19 90 21\n 71 79 62 94 71 66 90 64 39 64 47 46 96 79 29 13 22 50 72 6 56 84 52 85 70 97 63 86 60 68 63 78 56 1 83 52 92 42 24 33 8 92 90 74 54 8 57 31 87 75 50 53 71 79 16 77 8 37 75 46 13 79 17 38 9 13 19 6 74 59 69 46 64 36 38 15 19 88 23 63 62 80 7 30 51 72 80 75 38 57 40 92 65 52 66 23 27 40 89 6\n 64 10 62 58 91 92 49 30 93 44 25 76 43 22 49 27 69 18 69 33 29 66 14 38 15 11 42 62 2 78 94 32 24 58 89 46 29 26 31 46 38 88 70 70 60 15 66 27 78 61 89 62 18 73 69 5 44 14 22 88 29 98 13 60 44 38 8 61 82 69 53 66 31 48 52 97 48 6 25 19 31 25 76 60 71 21 26 19 19 42 23 90 72 26 82 12 83 60 54 95\n 55 29 20 90 6 20 27 60 61 10 44 16 75 58 75 81 21 96 53 63 72 95 92 14 52 91 51 20 54 55 13 77 66 41 22 44 50 89 90 17 56 25 67 7 64 52 10 32 42 66 39 95 13 37 56 98 90 84 11 70 40 77 45 32 80 26 61 95 42 48 67 19 14 98 99 45 36 72 21 88 50 94 17 11 70 49 52 28 68 51 65 29 32 27 79 30 93 79 9 71\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 1528387973 5875 5779\nprocessing times :\n 73 39 77 45 7 96 62 56 78 60 85 5 97 93 2 79 71 22 28 91 26 75 32 19 60 29 97 30 78 33 89 90 99 89 54 54 42 38 84 41 61 32 11 58 84 31 48 94 32 68 87 95 72 42 49 53 85 26 51 81 7 43 79 27 66 27 92 29 87 57 67 95 10 84 25 96 27 35 59 1 55 30 78 29 76 39 10 89 77 49 56 52 43 37 22 85 61 49 82 49\n 11 37 29 94 18 59 62 65 38 72 40 93 68 62 82 56 94 52 82 40 20 58 3 92 63 73 30 61 41 60 19 33 96 56 96 9 67 88 76 19 34 64 48 77 18 30 2 53 42 82 11 6 19 3 96 47 61 93 76 35 60 76 70 6 95 42 61 40 27 70 69 74 44 13 26 71 94 56 15 7 5 86 66 19 30 54 15 83 74 66 8 46 85 69 2 97 8 8 10 44\n 23 51 47 54 90 24 44 63 61 16 16 41 60 98 32 42 49 36 41 39 29 41 58 30 55 22 11 54 37 62 40 67 29 31 37 44 27 4 19 21 41 41 68 84 56 52 66 19 66 97 77 93 34 12 95 52 27 93 95 74 56 92 87 48 32 69 6 18 94 46 40 32 60 84 24 37 51 9 43 89 66 94 8 4 58 59 16 44 29 99 8 1 76 66 14 2 59 93 60 11\n 7 56 89 3 93 30 56 33 54 42 94 41 4 40 10 25 24 82 33 20 37 92 27 1 74 83 38 77 48 72 55 25 72 12 65 25 1 31 58 3 84 42 23 3 60 24 89 47 30 35 94 3 64 34 90 70 9 72 90 32 71 53 66 22 11 77 32 60 3 21 83 49 26 75 50 61 20 80 15 32 88 36 15 90 79 41 12 41 97 94 5 15 77 4 97 46 85 5 38 83\n 83 35 37 51 6 18 91 94 24 4 75 22 93 93 69 83 4 83 32 62 70 11 78 59 73 90 79 93 20 35 1 78 24 87 76 85 18 40 73 88 25 57 46 16 67 33 75 61 57 39 6 53 28 52 31 71 29 13 33 58 88 7 62 85 32 30 6 87 99 96 86 85 24 94 56 64 13 85 41 74 56 37 90 71 84 19 94 23 61 52 26 5 70 28 11 43 59 78 85 53\n 40 31 40 37 61 2 52 97 23 92 71 94 77 63 7 37 89 13 26 70 39 47 17 43 38 5 79 88 46 61 94 74 72 15 12 23 70 4 96 79 97 68 17 40 16 20 2 2 27 12 28 72 30 14 19 43 62 76 15 25 50 19 43 35 67 78 74 80 88 71 70 1 23 41 44 34 34 85 66 76 50 86 11 8 67 19 98 82 66 41 2 45 8 88 99 75 8 22 31 28\n 62 52 23 64 71 54 70 48 31 18 24 46 66 25 84 30 76 10 63 46 81 86 48 29 43 86 90 9 76 97 88 63 54 10 47 95 25 23 27 92 76 59 22 60 88 93 92 16 77 31 44 45 28 6 63 12 69 53 15 46 19 26 52 2 18 4 64 62 36 59 62 81 96 9 26 46 98 95 84 35 86 81 52 75 51 52 51 98 65 20 87 19 20 41 9 21 12 64 63 94\n 55 62 17 23 5 26 40 36 36 55 45 78 99 58 50 87 17 37 18 41 68 89 36 95 6 58 21 95 78 78 7 83 54 25 99 23 84 17 73 51 38 12 56 39 8 8 86 47 24 88 47 6 91 85 62 84 61 65 93 26 17 98 72 42 33 80 18 34 31 72 26 67 70 14 72 25 80 71 92 74 58 27 96 49 33 74 11 4 58 19 11 83 90 44 95 27 93 35 71 96\n 90 32 53 60 68 59 66 81 3 90 21 77 97 42 94 88 42 81 59 73 13 97 92 33 55 36 89 64 51 37 87 17 11 72 93 52 98 91 30 52 69 39 59 43 84 26 62 45 89 88 47 85 57 49 83 40 50 20 85 2 79 10 98 51 96 35 32 18 66 9 51 62 34 4 65 38 28 37 50 30 32 67 13 87 6 93 78 31 16 63 37 60 91 56 5 78 85 9 5 20\n 41 76 42 47 94 93 51 34 37 65 32 85 33 99 99 85 34 14 16 55 24 83 69 98 57 42 24 83 19 65 74 77 1 73 68 17 75 91 85 90 79 80 23 95 82 33 57 93 38 99 93 47 17 84 4 76 59 59 10 82 99 47 22 10 26 52 83 62 84 42 87 28 8 60 47 46 85 90 54 78 32 83 59 48 5 61 25 80 76 4 18 28 82 74 21 11 32 45 11 77\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 10 993794175 5845 5830\nprocessing times :\n 80 65 79 47 17 93 56 24 22 40 71 96 59 6 49 63 45 61 33 29 56 10 88 67 86 80 74 65 64 33 72 4 32 24 23 96 65 84 95 87 51 9 79 51 49 8 58 95 44 84 42 28 16 56 71 86 28 73 28 93 56 95 7 56 73 13 98 41 88 36 19 8 13 85 8 44 90 28 93 13 95 2 10 8 99 61 81 53 30 99 82 42 83 47 8 59 40 69 38 29\n 13 20 78 41 80 12 48 56 95 66 27 67 93 43 99 4 27 18 72 12 55 78 95 81 25 69 88 31 47 75 32 87 50 40 18 53 10 31 74 89 27 47 99 48 73 6 76 34 18 52 40 51 91 14 29 17 37 78 90 41 72 67 11 68 97 5 73 45 94 66 40 33 53 18 8 74 84 22 25 79 4 55 50 3 74 35 28 11 42 43 1 54 94 44 47 87 48 32 46 20\n 14 17 56 83 77 39 24 63 18 85 30 51 44 95 23 67 75 75 62 71 18 45 40 17 58 66 78 22 23 2 73 44 95 15 95 14 35 36 55 9 55 78 97 95 25 74 93 6 92 12 75 3 84 38 87 68 51 24 85 45 68 45 1 32 3 63 29 53 36 94 3 96 56 44 74 21 36 31 99 44 66 28 27 54 86 90 58 66 17 96 74 59 44 20 33 14 35 24 16 37\n 90 52 6 48 74 63 46 57 17 18 47 71 92 4 46 60 32 38 46 46 16 9 36 90 59 86 87 66 98 16 70 34 26 70 98 5 54 53 44 20 77 31 6 65 17 38 14 34 45 9 41 22 63 84 21 20 12 17 33 20 82 18 17 53 52 68 43 6 71 37 41 96 93 60 55 31 70 71 28 71 14 17 92 14 18 33 8 49 10 49 66 1 93 78 45 31 38 89 14 44\n 46 50 52 73 58 19 51 11 70 24 62 68 2 20 38 18 18 53 66 75 57 38 42 77 28 36 63 24 69 26 23 57 72 70 17 48 91 91 95 26 62 90 15 35 91 95 27 27 7 31 97 38 76 68 83 23 67 41 52 63 93 67 77 95 67 20 60 19 3 92 5 52 65 85 13 43 66 59 11 45 18 88 59 57 83 37 8 24 39 72 91 20 34 80 88 88 1 73 22 63\n 73 7 55 74 30 15 25 18 74 45 99 49 2 69 18 33 38 70 22 19 31 94 31 9 84 78 8 81 24 70 71 99 60 78 91 65 48 78 84 12 94 53 79 7 73 81 66 26 58 98 95 41 69 15 8 53 38 36 92 81 62 23 55 55 85 16 93 36 16 25 40 69 45 2 22 21 44 47 75 57 10 93 85 52 16 31 10 93 59 30 87 75 72 14 93 33 19 81 38 36\n 84 81 92 19 83 3 71 18 10 34 71 89 52 47 8 91 68 58 63 44 57 44 52 72 51 99 51 96 50 80 11 53 39 14 71 47 39 5 48 76 98 64 85 68 96 40 42 2 97 95 94 28 45 6 39 49 19 85 94 35 99 80 61 39 84 64 25 91 62 13 18 29 39 44 55 92 4 45 53 62 6 28 85 27 37 69 49 33 84 29 53 81 14 11 70 86 51 75 86 39\n 69 91 39 9 36 15 71 55 21 86 82 67 47 32 97 61 29 49 54 92 98 93 84 30 14 43 26 18 92 63 90 20 84 5 76 58 98 68 37 36 1 43 84 83 96 98 3 87 99 34 90 90 39 55 44 93 5 97 60 99 30 51 39 2 68 41 60 36 41 61 62 13 22 61 63 17 23 4 25 76 13 13 64 38 1 88 38 9 31 82 62 81 61 81 71 79 6 57 83 93\n 35 23 57 85 59 80 81 45 23 43 43 16 70 22 26 8 13 67 8 85 54 81 73 6 72 9 43 25 11 75 22 14 97 5 14 89 34 39 40 36 77 52 66 82 51 85 57 6 84 59 76 70 49 65 86 46 2 68 25 84 30 3 59 35 52 52 34 66 20 91 44 42 5 90 30 89 54 54 3 16 89 23 72 1 85 84 73 59 59 75 9 30 42 52 38 16 23 15 68 26\n 77 27 24 70 37 90 10 74 63 3 78 69 90 41 67 28 73 55 45 18 37 36 36 56 87 40 24 99 13 95 63 24 65 2 93 73 93 55 86 99 23 32 78 28 94 59 72 57 46 88 30 9 50 61 37 44 66 84 52 71 41 7 70 72 54 73 61 4 66 35 83 52 17 38 29 80 58 72 94 94 74 27 76 8 94 16 74 81 47 63 10 85 98 64 81 89 77 72 20 24\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j100_m20.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 450926852 6286 5851\nprocessing times :\n 12 72 29 16 22 61 69 71 86 16 54 53 64 96 79 68 98 87 40 74 22 23 47 55 21 90 68 14 42 41 40 63 23 75 4 31 87 25 47 70 1 49 59 11 93 38 5 43 82 33 26 89 86 10 16 72 96 47 9 56 8 69 87 84 62 52 82 66 67 33 3 53 95 42 59 77 38 12 1 66 24 17 58 71 88 63 60 86 8 8 44 99 80 76 94 75 63 57 76 34\n 27 97 53 16 36 28 50 41 42 86 2 45 86 43 92 73 99 84 83 61 7 8 62 3 21 50 71 95 70 60 4 58 16 30 80 71 59 75 52 25 86 48 53 54 98 36 9 78 80 88 52 30 62 8 45 77 90 52 39 95 86 15 98 59 22 43 85 93 6 46 51 97 79 46 71 18 33 13 3 32 28 48 8 42 26 26 95 44 74 82 28 4 42 81 56 38 50 12 43 51\n 24 57 68 58 76 70 72 56 56 55 89 23 42 26 87 17 38 24 82 55 47 7 99 89 20 65 3 45 89 96 16 42 70 69 77 46 20 71 91 8 34 72 40 82 60 59 59 43 72 10 63 67 12 41 5 25 67 95 46 37 41 2 25 99 48 24 18 10 23 66 82 84 14 13 88 7 40 20 68 22 92 53 16 10 23 88 65 11 89 78 94 32 64 42 74 87 63 94 87 72\n 42 16 44 75 32 66 31 6 6 52 7 92 45 70 72 48 86 63 61 92 73 49 53 20 97 58 59 29 98 61 83 8 83 73 2 56 7 15 55 3 73 13 47 76 15 43 44 13 16 18 16 18 3 11 98 9 28 44 14 39 76 92 59 95 11 55 56 16 56 23 84 22 32 40 47 92 61 51 74 85 6 13 32 8 43 30 53 24 2 11 33 27 35 40 40 96 69 23 32 13\n 5 42 47 47 47 78 94 18 14 97 54 73 94 17 97 7 94 94 68 4 60 70 68 22 17 59 98 55 76 3 21 10 11 44 29 43 60 14 46 3 60 72 90 1 42 74 54 41 15 38 24 91 49 23 63 88 1 30 85 22 94 39 70 85 7 65 43 4 60 90 73 21 25 33 48 25 27 37 63 28 88 27 94 20 54 17 74 35 15 53 64 38 79 45 67 93 16 59 47 95\n 27 69 38 66 21 65 3 7 10 11 41 64 9 15 71 86 2 26 57 78 84 20 21 3 39 64 51 83 12 16 3 1 88 80 77 2 14 60 45 39 32 97 98 65 86 6 14 99 93 54 54 92 57 39 13 70 73 16 43 9 2 76 38 66 21 32 78 41 52 88 76 14 86 35 81 32 75 38 55 96 19 35 41 77 36 24 52 60 43 30 86 6 8 31 80 82 2 59 47 21\n 51 9 22 15 84 38 71 11 45 48 29 31 14 56 59 35 7 20 48 88 54 30 81 2 1 78 8 8 71 60 41 39 8 96 3 79 48 23 38 85 32 69 56 99 51 59 47 79 67 83 58 49 50 19 64 5 5 52 15 26 67 11 77 74 88 83 96 73 59 94 15 50 20 54 16 33 9 74 11 21 97 15 43 2 1 74 37 61 3 75 41 86 51 65 42 50 48 88 52 46\n 48 44 73 95 72 12 30 22 25 92 5 44 90 35 24 64 82 7 34 91 59 5 47 96 7 53 60 77 61 14 88 97 92 65 73 19 99 92 19 66 25 79 36 10 23 37 76 83 58 99 29 35 49 89 79 82 92 45 42 21 51 30 70 2 20 82 13 92 91 2 80 38 54 45 19 65 35 66 26 18 32 51 23 18 87 74 10 76 31 31 93 61 26 39 83 11 57 81 40 97\n 42 18 31 18 55 82 64 36 48 74 17 60 18 88 37 29 19 51 20 7 43 77 95 92 27 70 91 74 62 80 85 8 39 85 83 76 31 12 69 26 54 91 61 27 88 53 47 39 14 78 90 90 50 64 94 79 10 18 7 26 51 23 43 95 57 30 86 80 55 76 12 91 95 28 12 18 80 32 67 2 4 30 64 69 76 92 50 35 20 23 52 25 82 18 2 29 70 7 36 96\n 31 49 78 23 37 34 43 7 69 97 15 38 80 78 89 95 1 18 11 11 92 99 81 79 53 47 48 32 58 33 65 86 60 47 89 40 72 54 29 57 93 65 39 8 87 57 5 56 80 2 17 84 86 65 53 5 16 58 60 78 25 71 93 99 6 62 60 33 57 79 7 69 82 26 41 52 38 21 84 74 76 16 75 75 36 79 71 82 70 22 39 8 22 79 90 55 77 3 20 61\n 48 92 43 35 7 51 85 66 87 71 16 40 22 12 2 90 63 52 15 6 18 87 66 7 43 27 78 80 73 86 82 33 92 8 87 64 7 26 79 49 71 72 69 30 28 46 75 78 34 4 23 69 33 11 5 54 42 12 40 30 51 94 24 28 84 69 44 98 36 21 9 48 30 15 21 43 91 49 86 36 41 10 75 56 70 73 57 51 34 62 3 34 27 29 25 97 30 28 48 99\n 51 84 28 63 86 99 27 24 36 83 24 54 34 49 43 5 70 56 71 12 30 77 55 92 78 79 52 19 16 21 37 85 56 29 56 23 19 52 39 4 46 59 22 76 34 63 32 72 92 72 26 46 30 49 3 81 4 46 95 20 56 57 85 31 44 1 11 72 6 68 62 18 21 48 32 42 79 74 82 3 64 90 10 72 2 49 88 53 59 88 97 98 94 95 93 95 6 1 15 66\n 8 37 33 4 8 38 97 75 76 93 69 10 25 40 88 90 57 39 29 97 51 97 5 75 91 80 81 60 97 14 2 55 97 60 8 30 87 42 16 56 86 4 30 15 24 23 57 81 77 43 82 97 3 46 86 62 26 56 67 87 46 66 53 34 52 81 68 48 4 25 76 46 13 72 72 82 32 25 58 17 99 54 81 73 93 73 79 54 72 37 68 22 94 37 15 31 46 33 82 75\n 1 77 92 57 46 75 2 14 14 79 64 8 73 15 71 6 54 59 49 38 21 60 8 35 81 96 61 89 58 32 59 89 99 7 79 38 1 67 63 42 3 29 23 21 25 48 33 92 2 12 32 38 67 93 80 75 59 51 7 65 6 59 30 67 41 32 63 7 8 89 51 81 9 13 27 74 59 98 31 98 48 74 76 75 78 11 71 54 10 96 97 75 41 30 73 84 22 8 98 68\n 1 59 53 22 10 48 94 46 57 55 66 69 7 13 64 83 39 46 59 36 69 47 83 25 12 28 30 49 81 56 96 89 73 52 12 98 12 40 70 35 58 95 41 71 90 3 68 5 18 26 2 21 86 8 33 88 33 65 8 89 46 76 57 51 58 62 59 71 12 11 82 56 57 53 45 96 31 39 12 13 8 49 4 33 22 30 34 19 24 56 96 35 43 8 5 65 64 20 54 38\n 28 81 96 99 79 97 15 6 77 98 5 51 51 60 17 98 46 87 44 18 71 93 97 44 18 59 9 45 78 67 65 50 87 29 80 14 70 10 30 19 51 4 23 9 62 30 20 69 88 22 43 63 67 22 82 41 69 81 21 54 42 53 52 26 69 80 46 10 81 99 6 90 79 34 56 75 54 94 84 55 64 14 18 6 27 20 54 30 58 35 66 85 78 15 29 31 45 41 84 51\n 4 40 5 37 80 46 14 81 16 10 79 35 41 83 13 93 55 48 35 75 66 82 3 79 78 48 99 91 29 87 27 2 48 33 92 15 55 24 59 41 49 88 67 49 81 89 43 24 70 74 44 23 89 96 80 44 69 7 10 15 55 27 55 2 82 42 88 84 38 69 31 5 3 37 14 35 61 43 38 48 89 86 37 20 33 1 8 61 41 40 10 10 75 9 81 40 13 10 53 28\n 44 6 18 51 77 47 27 17 42 84 3 69 3 6 94 58 65 36 28 68 73 81 12 89 53 14 88 78 63 81 29 15 81 84 36 8 60 24 57 87 61 57 85 45 69 15 7 87 58 61 82 73 84 63 14 73 84 9 38 67 76 18 70 69 4 58 66 11 1 51 38 16 81 39 56 83 27 29 93 70 64 22 84 25 73 81 10 46 32 38 68 40 33 79 64 36 62 82 44 99\n 6 49 84 72 39 51 77 59 97 5 83 51 9 9 59 30 86 49 46 13 45 51 68 82 6 99 12 8 36 24 82 73 66 69 71 70 61 42 77 10 2 6 24 97 15 91 32 68 17 1 49 25 46 37 56 50 9 62 10 89 66 98 10 70 92 36 82 54 34 34 5 12 3 56 44 41 14 25 78 25 89 83 78 23 51 7 20 30 30 30 63 82 40 39 37 44 2 27 71 45\n 57 88 88 43 25 81 3 3 78 97 74 71 50 70 23 43 51 97 57 77 90 58 75 4 12 2 4 28 54 39 30 71 89 33 85 2 69 20 64 94 3 41 37 36 74 53 49 77 13 37 34 31 15 32 45 50 81 46 93 13 47 50 70 21 41 12 18 28 22 60 69 49 38 80 52 45 34 3 61 96 99 49 78 34 78 79 64 55 63 24 58 25 93 73 45 93 37 64 92 59\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 1462772409 6241 6099\nprocessing times :\n 20 24 40 36 31 46 59 28 99 7 74 84 13 40 68 85 35 39 11 79 58 89 71 81 84 36 79 77 36 1 18 64 79 6 54 67 97 73 84 48 80 13 33 57 10 11 21 72 5 16 72 75 15 5 25 67 37 73 13 31 19 14 41 89 2 48 97 22 8 41 25 26 50 99 24 22 88 51 78 28 50 47 62 41 53 96 36 48 35 54 10 80 96 90 11 65 44 27 11 51\n 70 33 54 8 19 76 29 91 62 57 31 61 69 40 16 47 84 88 20 6 94 40 52 79 65 81 2 85 32 82 63 88 25 47 58 42 96 66 31 39 7 64 92 47 64 16 72 99 6 15 26 33 76 72 56 86 84 38 55 78 84 30 88 71 43 24 31 28 81 46 21 37 72 65 35 29 31 16 28 82 17 17 34 94 86 41 66 70 81 1 60 35 9 88 36 95 25 42 33 27\n 3 21 75 41 50 39 32 87 9 72 56 38 79 36 89 1 62 73 45 54 81 70 7 56 61 6 67 87 9 58 71 4 34 94 34 2 69 33 85 63 48 60 16 57 49 83 90 62 25 12 72 86 63 53 49 30 29 53 92 58 84 27 82 13 96 58 81 48 1 40 74 68 70 71 28 23 47 71 23 34 53 34 79 62 53 64 44 62 10 85 12 68 27 27 34 14 35 16 75 59\n 28 70 36 45 3 31 87 92 4 68 93 87 67 22 9 50 81 60 21 2 93 99 97 28 9 14 44 87 71 84 3 35 99 27 53 10 12 75 22 32 85 43 31 31 57 91 22 10 62 40 26 11 93 59 75 83 60 69 65 34 25 53 40 97 3 3 88 35 53 38 57 37 53 31 3 85 26 67 8 60 72 42 49 62 84 82 58 94 54 32 83 78 88 45 99 34 73 92 4 19\n 91 97 41 72 75 40 67 11 53 21 84 85 18 57 26 80 16 22 92 36 93 34 13 78 35 85 86 47 88 50 41 30 90 96 38 56 55 3 99 23 44 89 9 65 53 43 33 1 7 5 92 69 98 71 59 96 77 82 14 82 11 96 78 14 42 2 82 32 10 8 70 45 93 74 45 9 98 49 4 75 53 28 51 93 92 59 68 96 38 89 23 70 39 64 12 60 33 74 17 17\n 39 85 18 90 31 14 93 48 45 31 76 38 60 87 8 58 79 61 18 94 99 93 28 7 74 62 57 7 73 92 15 88 10 81 18 50 33 90 71 82 98 20 42 70 51 50 5 64 80 50 57 84 6 95 21 8 9 10 31 78 58 26 79 35 16 53 72 30 33 38 23 49 54 56 60 91 3 67 2 49 85 30 25 12 22 30 12 53 51 50 31 65 37 81 18 35 37 58 94 75\n 94 7 77 96 40 14 21 41 95 38 33 53 24 8 52 99 79 59 91 98 49 4 27 2 29 70 6 64 57 50 84 66 84 47 78 76 32 97 14 57 55 68 10 36 90 3 66 16 57 54 80 9 26 56 76 80 77 29 21 72 33 52 2 40 6 59 22 50 35 77 99 22 36 78 10 2 78 90 58 63 65 45 89 51 11 64 38 83 26 2 21 21 64 60 31 48 25 21 43 14\n 10 64 76 5 8 70 85 75 8 24 84 14 93 23 11 73 7 33 73 8 75 73 74 65 45 46 34 51 14 24 61 21 68 11 28 70 80 1 80 69 52 19 65 63 70 57 28 2 25 12 58 45 3 24 36 50 55 36 2 43 35 23 9 26 95 8 67 90 33 97 94 30 45 45 28 39 91 85 93 60 53 59 49 40 48 45 77 22 83 73 87 4 72 77 1 35 38 59 6 47\n 99 53 70 92 77 27 84 48 17 37 27 38 28 5 69 35 87 76 30 96 59 26 81 58 55 11 99 23 51 59 49 27 1 60 71 12 15 9 60 91 66 35 42 27 52 33 74 73 10 63 26 5 56 30 53 59 88 24 23 45 55 99 32 54 41 59 31 55 49 37 72 91 81 74 87 17 69 66 58 27 32 27 33 28 69 44 29 48 87 24 36 37 91 62 7 34 31 6 75 4\n 75 65 18 24 52 62 80 58 85 90 61 72 9 12 95 15 30 86 73 97 57 20 78 64 55 46 8 53 17 26 55 66 31 35 1 53 41 74 69 4 67 97 13 60 1 35 7 77 54 62 82 69 59 20 56 77 23 80 12 3 97 76 45 38 89 36 60 59 18 74 24 95 17 74 79 61 91 59 42 6 5 87 87 10 55 58 13 53 5 49 97 5 88 62 71 96 47 15 78 45\n 47 12 19 32 63 78 77 51 59 54 48 96 52 42 57 30 34 77 80 7 11 2 91 99 5 43 39 64 8 26 71 32 73 26 91 92 55 51 11 22 75 49 95 88 6 19 99 73 27 50 25 33 94 35 63 44 80 7 72 95 40 48 41 15 18 31 68 99 79 78 95 37 37 50 79 30 2 30 78 99 42 99 16 58 35 84 84 35 20 4 9 44 35 5 68 43 69 9 78 57\n 94 93 53 63 41 81 74 37 52 24 45 19 72 62 78 83 98 83 58 61 47 16 28 48 63 74 45 36 29 38 66 62 96 22 95 81 92 20 51 71 30 23 77 20 1 96 32 13 8 36 18 64 58 1 72 10 20 6 40 91 56 39 68 50 93 71 79 57 5 95 41 12 84 81 88 32 94 37 31 25 92 74 49 10 76 11 44 32 89 56 69 76 65 47 53 39 41 89 39 20\n 56 31 66 73 96 31 41 79 66 49 39 28 24 85 64 37 85 40 35 77 30 26 41 6 19 83 52 54 71 86 45 78 61 5 87 43 44 42 30 12 7 18 80 53 6 81 29 22 49 1 79 56 15 36 48 31 57 49 20 67 20 34 78 27 40 46 23 28 84 33 87 76 18 3 77 50 96 75 91 12 34 51 54 37 82 69 49 19 69 48 96 13 4 28 74 7 24 98 30 97\n 59 94 87 22 59 30 2 55 36 73 98 15 54 55 3 54 89 50 68 9 81 42 11 12 55 75 10 91 87 5 44 56 18 89 51 94 11 56 37 85 55 33 9 20 26 80 98 88 55 78 53 46 3 56 46 34 27 21 81 14 52 50 80 48 22 10 56 18 67 63 47 43 71 4 29 99 6 19 56 96 44 94 83 30 65 61 21 76 8 99 68 42 38 44 7 3 61 10 84 78\n 74 26 84 41 3 46 39 90 62 63 74 4 37 75 72 30 43 95 41 97 70 92 36 70 37 36 42 34 29 80 91 56 71 14 31 75 80 73 32 56 84 20 64 44 69 63 94 86 66 97 25 90 12 62 83 32 12 38 22 92 63 61 46 6 83 49 78 84 97 56 76 9 38 21 80 47 24 95 80 65 72 91 21 70 12 67 65 90 47 82 62 3 84 30 91 5 11 41 14 28\n 78 58 53 17 36 3 83 91 73 81 74 2 31 37 78 74 51 41 78 26 33 70 10 45 70 2 92 50 54 64 44 4 99 43 43 11 60 53 45 63 87 20 71 95 71 99 79 19 41 74 8 55 87 87 37 52 36 6 42 30 3 86 3 89 57 27 28 88 48 26 58 6 33 3 25 61 93 69 53 47 28 36 39 63 66 44 18 67 17 84 9 33 80 27 42 60 96 81 31 88\n 17 60 51 61 26 60 80 45 20 62 55 25 68 56 5 14 20 19 92 88 23 78 35 94 31 67 10 15 32 94 15 53 42 45 39 84 64 27 10 22 14 8 70 91 23 35 6 52 93 26 89 49 89 60 6 60 24 70 42 86 64 47 19 17 30 79 53 71 77 95 73 97 32 25 85 79 17 31 78 31 21 5 34 96 95 63 4 60 35 6 75 41 61 11 74 52 60 43 50 66\n 74 71 89 81 59 62 64 62 67 68 87 47 60 10 76 46 56 48 61 13 13 38 37 11 12 63 97 26 27 89 74 80 83 49 79 49 44 30 30 53 46 26 31 1 43 27 91 70 89 68 2 82 72 29 12 37 46 50 93 77 6 77 7 63 21 85 67 77 95 52 97 79 21 20 7 54 71 79 22 77 59 11 69 85 7 85 42 44 74 69 68 64 37 4 89 96 92 74 33 90\n 12 5 15 16 64 6 65 53 19 93 21 38 54 46 33 38 32 12 90 46 8 78 95 28 47 10 16 45 18 4 98 35 85 77 4 33 87 47 5 81 25 31 83 45 23 30 89 40 92 48 63 63 76 90 1 24 1 77 91 78 93 32 97 85 91 40 67 84 31 5 89 59 69 68 46 4 90 76 97 33 23 46 36 70 98 45 49 50 52 67 6 58 71 53 36 80 8 27 21 66\n 98 97 69 24 10 7 79 84 50 86 24 28 73 72 19 20 8 20 45 59 51 54 58 16 38 94 72 69 14 83 86 58 61 77 63 67 1 59 18 26 45 82 78 43 61 2 70 52 99 60 97 1 76 8 15 69 5 31 39 34 9 81 34 16 14 13 36 73 6 43 29 68 59 76 86 43 12 18 55 21 9 47 17 49 28 12 84 12 62 15 7 26 58 30 5 7 40 50 30 64\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 1021685265 6329 6099\nprocessing times :\n 9 93 84 58 14 31 19 16 41 9 67 74 85 90 77 40 33 42 74 16 45 62 44 68 76 76 78 29 15 30 93 16 38 27 32 31 88 79 86 61 30 55 8 90 70 58 35 11 66 63 26 92 29 98 59 18 39 1 27 4 38 42 69 4 68 30 39 75 87 45 83 30 55 37 31 74 49 18 76 46 78 99 58 84 89 74 1 86 95 58 17 18 70 49 21 43 26 67 66 89\n 66 63 88 45 52 89 83 80 58 52 21 34 96 69 81 65 61 82 75 61 22 52 10 50 30 84 86 16 54 54 70 37 18 96 80 80 21 58 70 71 62 4 1 4 69 70 77 28 47 78 64 58 47 17 67 84 59 51 47 61 51 97 65 7 71 75 47 83 1 46 54 76 54 59 37 47 55 76 75 23 41 28 78 58 51 40 16 21 88 59 3 39 73 34 45 20 66 35 96 24\n 79 2 54 78 71 65 95 21 18 54 1 87 29 19 38 44 46 25 48 66 81 42 48 34 73 32 68 60 63 49 19 54 14 40 83 66 27 89 69 34 27 3 97 40 57 3 45 42 1 63 14 29 53 5 71 44 57 77 43 59 25 52 19 34 16 38 61 53 36 87 3 56 1 4 4 98 90 23 78 64 90 18 19 67 82 16 53 18 17 25 71 12 24 32 44 39 40 47 53 75\n 83 35 53 1 35 67 26 13 52 31 11 37 13 73 37 56 55 81 61 75 34 2 29 2 60 17 55 3 94 70 35 71 62 92 39 47 10 72 5 40 1 15 67 10 31 40 7 54 86 4 2 89 36 33 98 70 91 64 41 19 24 84 50 51 60 3 56 79 8 34 93 79 72 7 90 2 76 1 7 57 19 2 11 84 9 88 50 52 49 10 23 30 75 43 88 66 23 34 1 82\n 44 40 27 41 9 77 98 64 14 2 19 9 19 28 69 90 71 83 2 16 9 60 1 44 25 86 45 68 1 56 64 7 68 96 30 62 32 25 27 97 54 28 65 7 71 74 8 46 76 45 11 92 54 31 51 48 27 55 39 71 18 48 8 35 62 52 65 95 55 7 37 91 91 73 56 22 98 96 82 84 31 44 19 60 19 56 6 45 24 10 6 44 57 43 1 42 20 83 57 34\n 67 64 92 35 55 99 23 52 30 6 81 91 89 45 33 55 74 46 50 29 2 80 12 63 96 88 47 21 30 44 64 51 95 57 96 62 11 8 92 1 51 32 96 88 15 5 56 68 10 89 43 4 51 84 35 53 82 41 62 78 72 32 17 9 67 74 27 55 76 1 41 73 89 2 45 99 37 74 95 78 48 95 11 28 21 8 88 29 60 2 47 15 1 64 55 32 49 20 33 68\n 84 1 47 60 31 76 12 75 90 72 8 86 86 70 46 52 31 36 10 19 85 49 61 10 26 38 97 71 34 74 12 77 16 55 90 61 43 42 81 1 8 51 16 14 25 92 98 28 97 38 95 78 48 66 18 19 25 79 90 26 48 81 95 37 6 86 83 67 74 91 99 55 79 46 10 52 22 39 8 13 32 4 7 47 34 1 12 93 62 11 81 26 31 41 5 40 11 56 67 49\n 92 8 79 5 72 77 60 21 23 51 16 73 59 20 83 9 60 68 14 67 86 35 58 13 55 57 14 79 72 27 42 59 58 36 63 1 45 10 8 66 62 95 88 69 38 30 60 33 87 91 48 46 18 31 22 2 96 56 17 49 87 35 69 66 69 30 30 77 98 55 78 45 84 47 58 24 56 50 53 12 43 73 3 32 91 25 44 55 97 10 42 73 74 16 47 68 9 92 4 48\n 35 3 9 71 99 89 92 60 44 59 8 51 60 35 5 81 67 70 79 7 51 1 38 91 3 88 88 6 68 26 38 93 89 85 82 99 47 60 4 41 86 12 19 80 37 55 59 55 26 40 22 72 90 39 60 14 92 47 90 43 15 8 24 93 40 68 68 67 41 72 72 73 44 34 24 19 27 31 80 4 94 3 31 38 44 87 77 2 66 20 79 89 90 84 40 8 65 80 50 89\n 29 98 45 66 64 86 75 64 83 12 69 7 27 20 92 28 36 2 86 71 34 74 86 68 94 78 38 77 69 56 12 64 99 41 25 58 20 86 58 13 20 11 33 55 5 71 62 50 93 74 6 39 90 5 81 28 33 78 95 82 38 41 4 94 44 10 28 33 66 16 45 51 89 69 23 9 8 43 64 15 15 26 48 9 11 56 75 75 63 17 93 38 22 22 17 24 93 17 48 27\n 18 77 73 91 96 10 58 70 42 21 11 88 91 78 70 53 51 96 27 47 30 37 63 61 73 80 5 82 49 11 79 78 57 47 91 92 94 33 52 12 37 47 39 4 50 90 58 46 14 84 97 49 33 48 68 36 66 6 54 16 7 35 64 18 8 61 41 65 71 34 35 92 70 65 76 71 81 32 27 95 49 51 65 17 91 23 17 19 28 70 67 40 81 54 52 38 6 8 31 98\n 14 17 31 37 85 84 7 54 40 95 97 44 4 46 10 63 76 23 95 73 78 46 40 34 92 42 56 4 63 93 72 63 62 30 91 96 53 19 40 14 16 66 54 54 64 86 31 99 10 2 74 29 77 14 30 14 48 1 4 71 54 30 42 43 33 32 12 68 8 82 27 59 20 60 76 44 29 68 24 46 94 79 68 49 85 87 17 99 76 81 52 24 57 8 36 67 57 66 5 69\n 75 43 70 11 64 88 94 9 29 58 90 78 63 34 71 49 69 97 10 43 22 16 31 22 62 14 11 46 85 59 73 22 70 52 70 45 45 37 2 90 2 40 70 93 44 71 83 13 3 99 27 98 62 17 35 71 94 58 77 29 61 41 47 2 16 41 59 27 18 33 1 99 3 15 45 82 20 11 90 65 73 71 26 97 50 43 7 78 27 50 70 65 96 27 66 18 96 66 82 23\n 69 28 95 38 89 19 6 52 70 4 81 1 36 30 13 90 30 66 28 36 38 48 97 56 92 93 81 24 38 39 33 7 75 43 92 44 35 2 96 28 13 67 61 71 20 54 53 75 58 74 65 21 60 72 4 85 47 80 71 26 73 36 38 13 66 82 2 76 29 90 36 32 84 78 94 45 14 72 3 18 58 87 30 73 71 5 77 60 6 61 23 29 2 67 69 38 37 80 51 34\n 89 41 16 7 84 53 56 71 40 17 33 3 51 76 2 63 84 55 3 82 46 58 24 57 59 86 39 55 69 36 98 82 44 70 67 74 61 38 87 35 37 98 26 49 12 52 49 92 43 75 83 3 99 87 60 92 75 53 30 59 95 85 63 21 78 72 87 52 39 93 22 82 21 65 81 59 73 74 33 53 47 69 11 31 69 67 3 21 29 28 45 2 53 36 5 79 76 32 87 4\n 44 8 16 93 93 64 65 1 40 74 59 21 79 9 2 70 88 3 95 77 76 94 90 67 27 18 49 3 79 12 6 72 46 7 56 33 59 86 33 28 84 59 54 99 30 14 65 34 6 91 89 80 34 35 91 44 52 73 93 98 30 20 58 34 14 46 61 73 87 41 9 57 82 17 19 32 47 89 2 94 17 98 13 84 12 66 90 86 83 75 67 33 40 56 21 43 1 92 4 44\n 52 89 39 71 72 71 68 42 94 83 14 76 90 14 83 3 1 12 51 46 2 92 23 69 65 30 48 70 15 62 48 19 49 5 22 45 15 29 65 72 45 53 8 11 21 46 95 42 66 23 39 86 4 95 8 41 85 66 68 37 51 46 93 59 14 25 71 15 89 94 61 5 45 52 9 70 50 44 79 64 47 4 59 45 91 35 71 63 94 86 3 77 37 84 50 97 21 42 6 19\n 96 51 53 95 76 95 50 52 27 97 96 88 92 33 23 38 37 11 6 55 40 1 69 96 76 46 66 8 84 62 95 30 20 90 66 76 46 38 41 83 43 37 93 80 68 92 94 21 68 53 76 40 4 89 52 54 87 86 20 15 61 25 85 58 6 40 98 93 78 55 75 97 52 27 32 81 73 29 34 35 78 29 45 25 54 74 77 85 64 2 27 81 17 31 37 20 69 59 39 13\n 32 78 84 27 32 84 74 72 85 60 55 60 8 34 54 47 60 8 39 42 10 62 52 65 32 61 9 25 15 56 3 13 59 95 93 49 67 17 39 91 60 90 94 53 25 12 63 75 63 7 80 16 39 37 7 1 38 48 38 39 83 27 14 46 46 59 12 20 7 85 74 49 48 6 73 57 44 41 35 68 61 1 16 37 70 26 76 87 42 26 22 2 81 55 12 47 26 91 37 41\n 11 82 26 57 33 21 37 67 22 33 47 3 55 19 61 38 63 42 20 62 45 78 57 31 33 71 73 87 46 21 52 95 66 24 27 63 48 43 87 44 87 58 24 50 33 62 56 86 58 42 84 35 91 49 52 86 45 62 3 50 83 57 8 88 10 88 50 22 49 44 6 26 34 40 26 49 93 77 38 15 50 15 22 88 42 63 56 61 64 63 30 4 21 95 20 30 86 95 82 10\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 83696007 6306 6072\nprocessing times :\n 4 64 34 65 43 59 53 10 74 16 56 31 43 60 38 9 55 45 98 38 5 74 23 38 99 66 14 5 9 90 60 47 59 27 56 9 1 33 95 94 30 63 96 24 20 17 78 3 29 7 30 15 66 83 23 81 30 84 64 38 55 73 80 28 12 9 54 1 30 12 51 91 30 3 57 2 80 45 2 14 56 36 24 71 2 31 11 70 63 22 18 12 65 38 54 58 6 37 30 65\n 30 35 65 75 28 5 35 26 64 53 85 94 64 48 66 31 68 28 46 3 85 54 62 86 23 61 93 40 25 28 67 35 20 48 15 53 95 28 72 32 36 82 11 19 29 6 58 93 49 14 38 63 23 95 94 72 73 71 78 9 54 52 47 44 38 48 47 30 18 69 25 27 77 15 64 91 87 63 10 64 26 14 82 13 79 27 55 47 47 85 15 47 53 60 56 3 78 66 58 27\n 33 59 66 38 13 96 61 42 76 82 92 55 71 96 89 86 10 99 96 96 59 56 80 84 54 9 71 89 51 93 93 64 31 61 19 70 29 84 22 57 90 77 25 12 57 14 47 60 64 52 68 78 75 42 65 6 5 56 76 12 42 55 31 55 56 81 34 43 8 44 27 13 44 93 73 44 25 48 85 96 96 99 24 22 94 86 45 13 19 57 21 92 12 62 69 69 91 27 25 81\n 26 8 34 89 10 78 86 70 21 55 48 45 87 21 35 73 10 62 29 84 79 55 36 39 7 53 30 16 53 82 25 97 12 6 67 40 92 3 66 5 6 10 21 70 52 89 64 9 55 76 14 28 65 89 47 2 42 80 9 4 63 91 71 34 75 12 38 8 7 38 59 90 78 52 99 5 4 73 87 21 64 20 79 70 81 41 78 14 17 19 59 13 46 15 62 69 51 76 91 38\n 17 65 14 84 4 68 26 73 20 64 24 25 58 43 67 6 64 9 27 60 10 49 26 99 71 16 94 78 67 80 89 39 70 54 80 11 47 45 32 37 20 82 47 26 55 80 63 42 4 80 63 96 74 64 44 67 35 64 58 35 98 29 7 35 79 70 10 84 5 23 62 75 1 75 93 65 93 85 55 2 53 63 61 9 72 27 98 40 9 50 90 46 75 92 5 49 9 34 95 79\n 71 72 43 28 28 25 66 45 81 56 34 28 44 1 65 66 53 48 65 14 51 8 12 63 8 46 24 93 27 4 63 21 4 92 96 87 10 82 57 47 80 95 42 47 24 88 59 44 58 98 15 2 51 65 39 71 6 11 37 79 42 69 34 5 13 70 49 94 79 90 17 94 22 22 51 97 49 75 28 7 91 10 32 10 72 94 72 29 58 82 48 10 68 61 89 32 5 50 83 38\n 91 34 58 98 2 59 30 59 56 56 95 73 48 77 15 73 94 13 92 24 68 64 32 69 24 54 31 20 59 46 79 76 28 46 37 5 66 77 97 68 68 45 52 30 95 49 58 68 11 44 69 16 1 57 87 7 52 27 33 53 40 71 18 83 4 80 11 35 61 72 90 58 89 32 82 66 69 24 90 64 28 44 20 66 13 23 57 24 19 60 57 53 46 14 92 66 91 13 73 92\n 4 2 88 93 64 99 90 20 7 73 61 35 80 78 37 40 50 53 61 6 44 87 66 14 23 1 80 34 22 40 63 31 32 64 13 2 47 60 73 75 95 35 17 70 4 59 68 75 24 21 22 4 8 1 32 68 33 27 11 57 23 17 43 58 7 30 43 29 41 27 80 43 84 40 65 94 63 41 29 36 94 18 59 33 93 97 97 94 31 33 85 21 80 6 75 65 62 48 22 68\n 90 99 24 24 90 76 93 50 82 34 35 40 99 78 40 98 8 15 64 47 76 75 16 57 23 10 86 90 84 77 93 34 45 71 51 19 28 48 52 60 25 47 81 6 73 94 46 7 50 82 26 95 17 71 51 45 10 17 35 46 18 21 80 79 12 77 25 75 35 80 54 69 20 75 38 13 57 80 65 46 91 59 67 9 3 49 7 39 26 93 25 12 88 70 32 14 30 63 58 28\n 60 30 78 40 23 20 69 99 96 61 79 1 61 72 65 61 35 7 52 94 14 74 19 46 9 40 61 56 21 95 6 95 27 63 49 14 66 3 1 50 1 67 97 41 13 30 53 84 29 21 16 49 17 30 69 33 56 41 64 2 99 87 10 18 39 55 46 96 54 84 98 8 18 91 9 57 86 97 31 10 48 45 86 81 21 40 84 40 49 24 28 25 87 54 86 10 79 23 5 39\n 78 20 36 28 14 83 35 87 9 51 6 73 88 62 77 38 69 38 81 42 10 87 78 22 90 57 5 39 90 87 76 84 37 41 54 22 68 9 30 38 32 56 17 36 42 38 48 26 56 16 37 66 24 63 73 56 30 1 69 81 51 48 57 53 94 81 64 43 72 99 85 36 93 3 47 78 56 10 43 1 35 96 32 86 27 60 9 34 73 25 83 54 13 37 3 2 48 17 75 66\n 86 83 7 84 33 10 29 91 46 42 1 43 72 62 65 72 65 74 57 88 76 67 58 37 65 52 29 94 61 69 63 46 46 64 33 72 4 81 40 17 72 88 59 92 30 40 81 94 44 80 48 2 10 48 71 98 92 24 91 83 8 11 86 2 45 40 65 94 96 99 59 27 10 62 22 72 56 48 20 58 74 79 54 46 97 9 96 67 55 11 53 71 8 62 22 57 65 91 24 9\n 87 4 16 7 3 43 26 80 19 12 61 25 58 10 9 57 86 72 32 81 35 4 62 2 31 99 15 96 21 30 24 57 91 1 56 97 22 29 56 8 86 52 65 22 52 38 86 30 55 87 92 55 46 85 47 28 2 87 12 85 69 44 85 71 32 49 31 2 55 71 92 53 56 91 61 39 84 40 18 19 62 41 26 7 81 25 19 85 21 6 68 24 97 63 13 48 98 24 37 64\n 59 1 8 39 67 11 87 56 87 64 48 84 9 7 37 90 37 75 97 40 27 79 75 70 85 81 64 46 15 22 1 29 3 9 41 3 74 69 66 37 49 30 8 99 50 48 81 26 7 99 68 38 59 42 36 59 50 63 96 68 78 82 83 79 67 15 86 87 22 80 64 35 30 84 89 78 24 41 42 32 63 77 46 61 58 77 12 91 63 86 16 41 96 53 90 2 95 3 82 19\n 18 38 11 84 41 23 9 44 7 85 26 17 47 2 24 77 28 8 9 11 20 4 95 19 85 18 82 45 4 61 35 98 59 78 63 8 86 56 6 90 31 52 96 1 73 43 52 43 78 10 63 69 14 26 77 51 8 30 70 64 75 53 4 90 10 83 29 87 58 33 18 61 15 10 52 96 2 75 41 22 29 23 69 82 29 30 5 84 26 7 92 55 73 92 88 27 11 74 33 6\n 2 73 63 19 64 23 11 66 27 31 46 12 67 43 24 81 52 36 41 28 23 73 14 28 26 83 28 38 7 10 14 50 26 54 97 1 91 91 1 18 6 15 84 44 60 65 3 7 26 53 22 36 54 19 67 6 7 42 63 55 18 15 91 43 55 55 56 6 94 97 23 85 29 55 57 82 42 24 68 50 67 51 52 29 90 58 97 94 4 42 79 98 29 6 66 89 42 84 34 84\n 25 19 37 58 87 31 54 94 96 60 93 55 44 73 72 14 78 15 54 84 66 36 94 42 8 51 55 78 58 22 64 76 13 33 28 17 37 75 32 57 93 18 24 87 66 56 95 39 49 55 80 8 49 73 33 85 42 43 27 6 26 37 45 85 39 54 12 20 60 34 55 25 38 12 39 54 68 48 44 15 37 16 98 74 13 68 57 40 59 22 15 94 28 42 72 91 1 58 67 32\n 89 3 58 73 90 54 62 75 19 53 86 35 59 49 13 57 37 33 57 57 91 92 29 15 65 85 6 43 50 43 76 83 10 86 6 86 11 56 62 17 72 87 38 76 28 47 17 16 82 55 65 61 29 5 11 89 33 94 68 21 62 93 81 44 40 6 97 54 76 21 53 52 35 92 12 92 12 56 28 1 7 31 30 15 44 98 80 77 34 31 5 90 27 37 46 68 4 82 26 23\n 56 54 13 42 93 73 3 53 41 39 41 65 69 60 99 86 26 97 62 49 25 17 29 91 85 55 25 94 48 64 73 49 19 37 41 12 1 93 69 10 46 88 43 10 97 75 43 34 66 61 10 99 7 93 85 89 74 92 73 92 9 6 16 34 85 48 79 77 76 57 34 50 17 90 6 38 43 45 77 61 16 13 4 39 74 85 97 56 28 81 84 16 5 23 70 58 9 81 60 65\n 84 69 76 34 14 31 98 30 53 21 37 66 93 21 65 79 11 85 27 41 45 78 56 89 58 51 21 15 94 29 83 23 22 19 23 12 37 68 24 2 59 13 32 58 60 78 31 77 2 94 75 44 55 89 78 63 50 93 21 8 64 26 84 4 14 48 21 4 98 72 96 26 42 99 21 29 55 94 99 1 70 49 17 57 49 92 14 11 67 33 27 62 57 57 72 68 18 33 93 84\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 508154254 6377 6009\nprocessing times :\n 1 61 82 63 9 98 85 76 35 26 10 7 55 4 28 59 59 8 98 34 90 32 57 87 1 88 46 46 84 43 52 26 21 55 94 32 52 21 33 68 62 71 85 32 32 62 97 93 72 28 5 66 96 36 55 22 82 64 62 68 27 21 63 22 40 85 52 51 41 30 23 66 52 52 65 70 47 38 81 88 66 91 90 98 52 88 84 91 90 36 49 56 51 26 56 57 55 23 57 99\n 87 33 38 36 28 94 61 89 33 3 28 79 68 35 51 14 24 31 47 95 64 39 98 15 51 69 50 3 60 31 23 14 5 97 94 44 56 24 46 44 51 47 18 54 7 26 16 67 3 38 13 28 23 62 87 75 55 20 68 13 80 47 48 20 13 23 76 63 91 49 34 34 17 20 92 65 80 26 24 30 2 9 16 86 2 8 57 55 67 72 1 30 25 46 23 63 4 6 30 40\n 92 75 4 88 28 37 67 1 54 1 88 1 67 12 25 75 42 84 67 23 40 36 37 86 14 39 30 61 62 39 74 19 14 85 55 95 58 66 61 75 91 27 60 90 71 99 99 73 39 25 37 56 83 27 19 27 47 19 59 8 20 12 62 4 36 80 71 64 8 40 93 1 1 39 32 31 8 26 50 50 47 79 2 36 72 57 25 15 93 74 34 94 53 48 67 95 84 2 69 30\n 71 85 37 66 81 59 45 96 89 23 32 18 71 61 65 16 47 15 54 61 61 66 55 18 9 78 59 70 69 41 37 99 24 67 52 63 62 24 7 50 44 28 84 49 94 3 22 95 69 69 16 5 24 90 92 65 82 9 73 58 60 14 20 14 90 93 26 24 46 93 17 11 71 19 4 96 87 58 13 53 50 63 20 52 79 29 2 92 14 7 73 98 97 85 61 9 14 70 45 22\n 47 7 33 48 61 67 99 32 19 50 91 65 25 64 64 64 9 96 65 72 61 45 29 36 64 14 86 22 87 22 91 40 56 97 7 5 83 98 25 87 27 88 74 98 15 97 16 13 13 38 94 88 57 46 82 32 10 59 81 91 30 41 70 50 75 63 32 79 68 24 95 7 80 95 60 17 19 65 41 19 59 71 71 30 47 38 9 67 25 85 36 78 93 9 82 29 10 27 4 93\n 12 29 76 97 43 48 81 10 55 90 19 29 10 49 5 12 98 55 38 30 41 86 50 43 96 18 42 75 88 50 66 23 35 22 13 11 39 16 63 87 31 1 54 41 53 99 9 3 24 83 9 66 61 51 79 93 64 86 20 88 52 68 49 61 55 50 44 36 63 89 10 80 20 41 23 16 10 2 79 70 22 32 44 51 58 9 20 75 75 15 45 44 82 60 14 9 19 4 33 5\n 91 19 69 20 34 28 24 16 89 40 82 63 32 11 82 71 22 38 29 93 14 74 93 63 94 64 31 85 61 13 80 33 81 6 84 19 9 61 72 42 93 57 6 56 86 44 39 90 31 18 13 6 71 2 72 67 71 67 69 30 60 12 83 94 71 43 12 69 2 42 4 81 98 49 40 21 60 78 37 3 92 3 53 46 34 80 91 76 94 11 52 64 54 37 61 98 31 81 78 42\n 45 12 58 63 41 92 7 3 35 97 32 18 44 87 5 25 97 48 59 83 40 3 42 91 82 40 86 63 94 46 56 5 48 34 49 24 28 94 55 9 66 80 38 37 92 90 42 43 13 29 7 67 36 80 5 15 12 31 1 29 36 48 98 28 41 13 21 50 57 14 41 59 86 56 28 76 69 67 90 95 45 95 43 43 16 95 62 81 46 16 22 65 14 57 35 88 70 2 46 50\n 74 87 9 78 33 84 63 71 13 1 72 36 86 68 39 56 34 76 63 45 16 82 30 32 73 57 49 29 43 99 27 81 2 65 91 13 68 48 22 7 41 59 92 20 52 71 6 78 37 91 42 61 97 4 55 79 78 41 23 19 10 22 27 27 43 80 62 85 87 69 69 3 32 97 47 2 39 67 96 37 94 79 30 29 90 83 56 75 94 84 31 91 31 43 62 24 17 1 83 34\n 96 41 83 13 79 71 4 60 93 24 16 22 21 99 12 44 57 75 13 14 49 72 40 98 88 37 6 5 58 33 40 22 50 23 89 34 66 27 9 92 13 83 13 77 17 66 96 40 30 38 9 10 87 41 72 89 67 54 9 73 61 80 50 42 86 27 79 75 46 59 10 51 1 11 1 19 88 65 7 45 67 97 45 30 28 92 28 74 78 95 12 36 6 29 99 14 81 53 36 86\n 68 69 80 71 11 44 86 86 18 55 96 82 39 17 69 98 61 68 62 88 37 39 7 51 2 62 35 75 5 97 87 52 30 75 27 75 40 4 43 90 35 24 28 58 36 43 49 86 60 25 89 1 46 83 34 32 59 29 11 82 54 92 98 27 57 57 63 63 95 74 63 7 67 70 32 86 26 2 54 67 8 45 46 99 1 29 24 69 39 15 37 80 36 81 55 84 43 7 43 78\n 97 98 58 60 97 9 44 24 24 18 77 75 3 88 48 78 71 24 50 19 98 38 43 10 51 64 5 77 72 2 34 78 32 14 98 90 4 45 49 80 95 89 56 42 27 74 5 33 52 95 60 29 53 73 7 17 97 65 32 19 89 70 22 91 59 12 44 20 74 75 79 20 69 20 28 32 99 27 14 81 71 83 84 75 73 10 76 66 58 81 29 75 41 54 8 98 68 17 63 77\n 52 21 2 86 47 91 22 7 56 44 3 21 52 99 45 36 42 42 80 38 68 71 18 11 37 30 55 25 58 11 51 44 5 84 10 58 21 4 16 72 64 87 4 10 69 24 47 53 25 36 13 23 19 78 19 38 63 64 28 89 72 70 32 53 55 40 13 48 91 55 31 85 51 15 31 64 30 90 36 42 3 90 18 23 75 68 37 77 20 50 97 37 10 89 91 97 12 56 16 5\n 42 11 54 16 10 12 82 60 83 29 55 67 62 6 39 39 74 57 2 8 32 6 62 78 3 26 80 75 73 18 34 89 22 38 75 32 29 97 24 96 91 89 23 17 67 45 30 9 6 47 13 93 80 23 55 76 37 64 16 55 2 60 66 90 95 47 32 58 54 89 66 27 27 80 75 89 30 21 71 87 46 79 68 41 38 45 63 90 81 91 53 55 83 23 22 11 96 93 11 20\n 89 51 46 17 76 14 24 58 4 26 77 40 47 36 37 66 26 13 81 4 95 70 55 40 11 40 28 70 75 84 70 33 96 63 64 39 26 14 67 63 39 58 67 61 47 97 63 45 49 99 49 80 54 28 83 67 89 30 91 23 79 73 80 68 75 16 75 2 28 77 4 13 47 19 68 20 61 4 22 5 43 43 64 84 44 7 98 26 67 51 9 73 63 99 4 72 74 79 27 28\n 35 92 60 14 20 96 67 21 28 69 26 6 22 15 3 45 81 29 13 49 99 33 64 96 16 56 85 65 70 46 6 55 73 79 81 15 46 51 13 36 85 1 38 29 87 95 8 10 76 63 25 2 50 81 11 80 77 74 20 64 43 23 10 41 51 94 31 4 74 76 29 51 26 61 44 90 34 59 48 66 43 86 11 19 48 30 59 63 39 73 52 77 60 60 71 25 68 47 83 83\n 83 34 22 99 85 94 37 67 78 97 51 82 83 38 12 23 26 73 32 80 11 6 24 78 66 21 73 38 80 83 99 72 35 7 82 61 83 74 98 45 40 7 30 87 51 64 25 17 2 92 14 54 34 23 47 69 50 34 80 18 19 25 16 71 7 89 41 48 96 13 20 87 60 57 65 21 34 6 23 1 62 52 18 94 94 2 52 85 19 80 28 47 77 69 58 16 73 10 84 61\n 27 84 96 46 6 55 9 80 48 36 32 42 14 83 23 94 12 11 14 66 81 47 84 46 23 69 7 63 67 23 11 66 17 12 88 31 92 78 89 38 80 61 53 28 40 82 35 89 20 58 25 83 62 48 32 46 12 62 22 41 68 35 56 67 74 82 64 43 40 6 22 76 59 85 46 88 13 85 61 91 91 79 7 30 63 30 55 62 80 58 37 17 22 46 87 90 57 98 59 22\n 75 84 82 74 2 8 16 60 33 81 94 8 10 93 92 71 78 26 47 72 32 16 35 63 34 91 77 82 57 35 74 37 27 48 10 54 94 56 23 91 47 53 42 16 72 35 33 69 92 26 16 74 97 38 44 33 46 71 56 98 42 14 19 69 34 77 1 29 34 35 69 21 45 31 12 59 45 15 34 14 44 20 66 65 31 71 36 36 58 18 6 66 41 85 62 12 47 82 75 84\n 65 35 68 70 45 92 68 85 33 21 28 84 56 8 71 69 49 9 37 24 87 59 57 9 31 74 4 89 67 12 45 84 43 30 45 33 27 11 43 6 90 29 46 1 29 90 86 46 81 43 20 78 96 11 29 27 71 54 68 28 12 8 12 90 94 48 4 68 73 88 50 97 7 76 42 88 27 15 72 77 62 51 48 22 97 93 51 85 26 17 54 99 8 4 2 29 80 20 6 86\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 1861070898 6437 6144\nprocessing times :\n 43 50 51 88 95 52 15 25 2 21 74 1 89 78 14 48 91 33 46 1 39 51 62 77 77 29 82 39 62 27 47 17 60 15 94 97 65 35 5 1 66 49 3 33 98 45 3 25 74 61 57 90 81 15 66 1 89 31 20 46 93 78 41 30 42 71 6 16 76 63 54 38 88 36 69 51 67 54 76 47 37 15 6 62 19 7 97 37 37 60 81 28 87 95 85 76 69 44 70 24\n 31 19 14 10 78 15 91 35 79 78 45 79 47 33 75 81 66 78 41 38 55 75 5 57 67 12 21 88 47 42 12 25 32 89 11 34 10 95 9 88 79 60 59 81 4 58 40 95 81 1 67 68 38 40 28 5 26 59 77 60 69 57 43 90 30 46 49 77 67 54 7 38 26 83 95 44 84 41 5 12 87 16 4 83 97 58 80 22 1 89 98 92 90 20 14 76 23 54 18 34\n 67 37 74 4 15 93 4 9 33 97 79 75 91 79 23 60 97 55 76 14 2 3 3 64 94 63 48 67 32 15 45 31 10 70 75 71 50 25 74 94 7 79 25 74 14 95 54 74 44 44 25 21 12 6 56 19 75 35 64 89 99 36 32 53 67 68 97 9 16 55 91 5 81 67 86 26 41 48 28 19 88 37 40 23 27 11 8 5 87 39 32 23 82 32 95 19 88 29 54 11\n 26 49 42 15 66 67 40 97 13 54 23 1 74 95 45 3 80 78 31 76 52 79 71 58 9 61 20 53 62 45 25 59 71 96 34 50 25 36 18 34 39 39 81 62 25 82 91 26 63 78 91 13 94 52 7 71 1 84 38 61 32 49 63 72 86 63 80 87 55 53 99 7 35 72 45 14 36 35 86 81 41 58 34 43 47 10 23 36 56 84 53 85 32 8 33 67 65 35 19 92\n 20 64 97 82 36 99 41 30 80 70 61 42 51 15 16 60 47 15 26 96 82 98 59 19 1 50 16 2 6 68 86 62 58 23 12 89 19 31 70 68 29 47 43 47 45 92 81 44 84 64 30 58 95 96 92 54 18 20 27 59 22 93 6 95 58 12 16 93 40 87 5 41 88 92 64 45 13 61 51 70 81 25 54 97 85 7 65 84 80 65 21 9 32 95 20 28 64 29 82 82\n 22 39 64 56 9 17 55 40 87 60 92 11 51 78 3 73 48 38 92 81 85 90 46 72 58 60 94 85 94 63 23 92 45 97 14 80 59 30 24 44 99 33 90 25 54 91 61 29 1 59 64 60 75 83 41 27 94 22 96 21 53 77 85 33 20 1 90 71 62 94 86 61 15 87 53 30 77 9 34 2 39 54 8 44 12 93 18 88 21 54 94 5 43 89 98 99 43 85 80 7\n 77 26 69 97 76 37 50 99 80 68 24 47 7 70 91 87 73 7 20 70 3 7 12 76 2 66 45 13 33 66 8 54 4 50 98 38 52 58 57 13 8 9 8 95 27 28 17 38 72 89 53 51 99 24 98 52 67 31 34 61 60 17 82 25 12 61 84 89 11 25 50 11 61 81 14 72 86 87 7 57 81 33 52 4 73 98 2 27 46 84 7 48 67 86 6 36 14 86 75 21\n 94 51 39 5 19 71 76 23 92 81 88 8 71 9 68 16 87 3 7 38 69 23 17 27 60 75 65 33 47 60 23 30 73 4 82 8 36 20 70 42 62 49 21 3 18 96 41 94 41 58 27 38 8 21 26 5 2 65 58 83 10 34 29 82 89 32 47 43 42 42 16 7 11 27 46 78 73 27 69 38 41 38 50 28 76 39 51 57 39 46 69 15 22 7 67 16 50 76 13 11\n 11 54 39 65 70 17 17 99 97 45 35 50 5 48 75 71 44 60 59 24 39 64 39 1 65 65 1 12 97 31 21 71 1 37 89 24 15 94 22 94 33 84 45 19 48 89 33 63 38 26 3 64 6 65 89 13 71 22 2 33 99 71 51 61 33 57 56 33 32 52 86 6 9 88 87 57 98 92 39 38 78 54 31 53 92 69 52 87 11 34 67 52 30 9 78 34 14 24 64 6\n 23 2 29 60 1 88 17 54 8 9 10 20 12 7 5 68 16 79 54 55 41 26 6 78 35 74 68 72 6 73 12 18 85 3 66 72 72 61 22 77 86 46 72 31 27 8 67 5 88 31 55 36 65 96 96 96 91 82 3 47 4 93 74 12 95 82 42 99 57 44 79 48 23 31 57 55 52 4 83 88 67 67 20 34 41 59 74 35 8 26 90 25 23 23 71 1 72 49 73 18\n 30 34 75 91 2 45 7 99 91 52 52 28 3 80 77 36 98 60 81 47 50 48 35 17 80 49 90 98 45 25 12 15 8 23 28 62 97 30 50 70 77 2 75 88 52 1 41 53 16 75 68 99 6 2 18 35 77 57 60 60 85 93 50 38 54 11 7 5 15 23 2 73 14 44 51 43 78 74 31 99 95 52 40 2 27 56 12 19 76 83 48 59 62 56 96 18 58 29 4 27\n 40 81 34 19 84 72 55 36 23 93 27 39 1 92 77 36 23 42 83 97 92 58 9 25 87 88 69 79 9 48 9 14 19 89 21 32 15 77 28 98 15 80 76 54 90 44 34 3 34 9 36 77 4 46 15 96 1 25 39 32 42 9 36 83 34 49 53 43 74 80 49 13 61 77 31 30 61 79 59 38 54 19 50 24 77 99 88 91 25 4 5 56 81 73 82 46 87 46 85 76\n 99 12 33 43 99 19 87 90 8 23 34 31 39 46 62 94 71 8 42 48 22 36 47 47 33 56 75 11 83 59 3 39 46 24 60 20 91 61 16 61 98 44 5 12 45 35 55 35 90 22 66 70 17 22 67 87 34 36 94 36 23 13 36 56 18 50 39 71 59 80 35 77 78 79 46 36 3 56 72 77 82 97 18 32 87 20 40 55 40 1 84 37 26 47 68 4 50 8 51 4\n 66 85 81 9 32 62 60 68 30 53 47 35 93 71 16 15 11 26 85 85 47 29 95 4 92 66 20 65 31 91 65 16 30 78 9 90 2 11 37 84 43 77 14 24 71 17 53 84 83 50 83 82 62 63 6 29 66 13 60 24 94 38 55 26 62 73 91 16 90 37 14 81 19 84 18 54 39 61 29 25 66 69 12 73 50 23 36 25 90 28 27 73 17 28 84 83 27 84 37 28\n 12 44 89 11 63 62 20 19 75 43 94 16 75 51 9 61 68 80 14 76 18 44 63 17 29 36 69 83 53 31 71 61 55 85 35 62 87 48 91 25 95 38 85 22 12 89 84 70 35 59 29 15 66 87 43 54 84 85 8 2 89 58 71 69 80 25 74 66 60 8 14 27 63 31 96 57 14 32 2 3 72 44 33 72 1 72 9 65 79 38 49 93 38 72 31 51 89 90 95 76\n 75 21 81 70 94 67 70 92 87 83 90 57 53 77 37 37 45 36 79 53 37 29 79 49 2 16 36 39 9 5 35 54 98 61 18 41 15 19 75 17 4 19 7 44 54 55 46 46 84 73 28 52 32 51 21 92 60 87 54 30 60 36 59 39 16 55 22 41 13 99 25 2 54 55 23 62 98 46 82 70 83 72 21 56 36 41 5 7 1 23 2 48 65 6 75 6 43 67 26 79\n 64 66 16 11 36 87 99 3 73 18 31 3 10 77 25 98 65 5 46 4 21 49 83 44 71 48 63 88 87 28 6 7 32 85 1 54 59 10 95 42 2 11 32 71 24 56 23 71 85 91 49 88 33 63 69 28 99 52 53 14 23 50 37 93 18 77 84 28 61 81 82 29 88 80 64 29 19 1 34 68 57 15 78 95 7 28 76 48 2 12 67 7 24 42 91 17 79 95 86 96\n 21 30 19 49 15 57 66 98 4 75 95 99 24 4 43 53 81 29 31 58 65 97 68 14 56 44 24 21 15 87 17 3 28 85 56 22 60 52 4 31 58 38 36 4 34 19 22 74 24 18 9 82 96 97 98 78 35 26 48 67 78 87 2 97 57 62 81 73 49 60 97 22 12 8 35 42 44 67 46 24 68 68 5 84 58 1 84 59 67 2 74 5 58 96 34 50 92 15 74 90\n 43 47 50 94 39 17 67 63 88 98 8 13 81 76 9 70 78 60 58 22 40 30 23 61 88 34 20 83 85 29 40 41 84 61 60 31 78 41 45 55 27 7 26 54 48 56 51 52 91 64 54 68 61 2 50 61 46 41 16 88 4 67 57 11 65 99 4 89 93 8 47 22 26 89 77 10 8 66 48 69 99 51 63 51 95 95 23 65 72 92 74 75 46 88 46 56 74 66 47 9\n 84 73 59 32 38 33 35 83 49 64 6 99 41 95 50 58 45 18 2 77 88 85 24 70 51 70 69 45 20 32 46 99 67 68 33 74 78 87 95 89 38 45 71 33 53 78 44 9 18 23 35 85 60 9 94 53 32 34 59 95 10 2 38 71 93 24 31 73 77 91 94 58 48 93 90 85 78 60 38 55 63 70 84 16 25 56 66 51 99 4 52 87 29 83 22 56 12 36 88 77\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 26482542 6346 5991\nprocessing times :\n 26 99 68 38 74 84 3 38 60 87 87 88 68 37 99 62 75 54 8 36 85 20 68 55 22 48 9 38 44 37 63 60 43 97 42 68 45 46 19 69 66 22 42 54 2 94 95 69 15 38 15 53 43 94 90 92 3 31 74 35 51 75 61 27 17 31 9 70 56 98 67 57 41 78 60 7 15 21 43 26 42 82 7 43 14 1 62 71 26 96 17 75 5 38 28 20 32 85 97 36\n 10 37 69 91 75 54 37 44 37 69 45 56 6 76 60 41 13 92 74 44 41 16 6 74 50 18 62 96 50 12 46 54 53 72 10 52 88 95 41 91 5 37 47 96 53 14 6 4 15 7 96 43 12 42 89 86 7 56 20 34 77 24 85 52 93 31 65 94 45 20 79 19 3 96 84 18 26 52 68 28 84 23 1 44 3 37 42 1 55 76 41 71 40 31 9 8 46 20 66 19\n 96 7 16 74 74 50 76 65 34 69 64 47 28 59 45 19 69 37 41 39 28 2 77 48 57 75 88 46 97 64 15 7 88 41 89 95 77 13 88 70 85 68 4 31 67 67 75 9 9 44 24 16 25 42 88 85 17 32 36 60 85 15 65 68 62 60 27 9 97 73 41 89 95 71 7 79 75 15 86 9 74 45 83 31 84 70 63 2 42 79 59 59 11 73 44 13 63 25 68 94\n 51 11 52 11 22 20 52 60 95 57 17 77 48 10 97 62 11 54 35 12 40 99 73 60 9 70 7 35 36 75 20 89 20 10 73 54 88 70 25 48 2 67 56 59 7 32 61 32 59 33 60 72 79 89 42 49 4 94 30 23 89 7 76 35 47 77 47 10 88 16 88 82 34 52 79 77 74 8 69 11 18 37 47 84 17 70 74 26 90 53 74 87 30 8 60 60 74 34 46 26\n 22 57 50 63 22 18 85 89 35 93 14 94 90 39 69 89 93 80 40 50 33 90 12 92 96 50 25 15 65 8 57 66 29 20 35 59 1 73 45 79 64 54 49 24 81 94 67 70 39 87 21 13 90 70 71 86 41 23 18 63 9 50 87 43 33 18 28 21 61 57 69 9 18 68 8 24 90 7 47 32 95 70 86 86 8 71 23 50 53 32 6 38 93 66 1 99 62 5 37 41\n 56 24 10 91 7 95 47 96 30 96 91 3 45 18 9 50 81 91 70 96 98 15 42 11 67 87 24 8 43 70 83 49 38 46 75 13 12 35 96 7 10 89 91 36 33 52 34 94 73 36 27 27 81 1 1 83 22 73 98 2 88 32 78 57 74 30 56 90 5 48 98 36 55 54 7 85 61 94 88 33 78 89 18 14 46 20 89 17 65 80 13 70 7 43 24 23 31 38 63 43\n 43 51 85 51 86 23 33 86 12 94 2 36 96 63 10 66 18 79 98 58 45 97 46 32 11 63 6 38 32 29 87 42 8 8 90 48 89 94 47 23 59 61 58 83 89 95 3 78 46 5 8 59 25 67 15 90 99 38 19 77 61 55 12 8 95 88 55 81 9 32 62 50 75 66 43 87 40 98 42 49 50 29 28 35 48 37 42 11 38 24 97 45 54 28 4 68 89 86 39 71\n 91 78 60 42 29 77 65 60 97 88 72 62 6 88 12 57 78 96 9 18 24 68 45 6 29 18 40 70 62 62 9 86 15 76 23 40 63 39 24 36 24 89 9 18 89 32 56 77 76 8 56 85 79 72 50 39 69 96 94 83 76 55 33 15 76 36 54 67 56 92 18 67 94 28 1 33 36 18 3 65 44 79 86 19 58 30 64 4 65 57 73 37 44 51 21 15 63 65 28 82\n 72 40 88 94 27 83 82 53 44 6 86 18 14 47 26 46 88 48 8 66 89 16 49 46 3 12 21 55 15 2 87 17 68 76 87 77 77 12 56 57 7 46 69 2 69 5 77 53 39 55 17 3 54 18 12 96 82 67 8 25 55 25 76 2 59 72 88 48 75 44 10 22 42 98 33 52 1 99 37 74 35 15 58 15 41 48 94 96 89 8 82 36 31 13 26 40 77 83 44 77\n 41 61 28 93 79 81 38 41 63 90 66 77 51 41 11 35 44 5 14 61 27 80 30 66 10 18 73 9 68 94 97 96 21 73 6 13 53 79 66 39 35 38 18 82 62 37 93 84 48 58 56 88 24 37 94 4 92 88 37 3 70 30 92 54 94 72 86 18 23 28 11 33 57 84 71 31 47 38 34 25 95 20 39 90 17 58 98 39 99 44 45 53 88 8 17 13 72 60 62 2\n 28 96 51 98 40 5 48 96 51 80 90 8 81 65 92 50 27 53 26 61 57 9 74 6 68 51 18 10 25 6 56 42 43 63 50 91 32 81 92 85 40 70 51 48 7 44 75 99 91 22 93 88 29 94 11 13 47 12 81 77 15 97 64 87 33 93 65 89 3 97 3 31 80 47 8 79 62 80 11 95 5 83 48 23 8 60 54 12 97 98 36 95 69 46 93 44 92 71 63 74\n 80 54 21 17 79 75 95 86 95 22 86 24 75 34 10 65 63 2 70 6 39 6 82 55 63 48 39 26 80 92 32 76 38 93 22 17 48 25 74 60 34 14 92 95 51 50 96 89 94 10 91 50 72 60 98 27 85 71 63 29 34 61 56 35 9 12 53 67 16 68 12 45 25 83 76 7 97 63 78 76 40 57 37 93 92 54 92 42 29 85 3 10 6 53 34 45 78 96 17 85\n 27 80 35 75 49 86 63 30 33 70 34 86 19 65 56 95 62 72 77 17 72 62 43 85 75 80 45 95 89 33 93 83 19 52 57 55 24 4 96 31 17 93 23 34 27 70 26 80 4 48 81 76 28 64 47 4 46 84 20 77 66 21 94 77 53 34 53 48 18 89 76 86 42 57 77 86 71 21 4 5 2 66 81 49 42 14 4 64 30 52 86 34 86 94 94 3 60 90 35 96\n 7 2 31 22 82 9 59 31 69 44 57 59 11 7 69 5 61 13 30 63 63 59 90 24 19 53 38 75 40 35 95 6 85 94 21 84 92 49 49 98 38 28 60 38 58 82 20 39 24 43 76 3 28 82 26 71 4 71 93 75 98 84 35 53 45 18 32 59 2 33 63 47 99 8 41 23 38 49 86 54 12 57 1 3 63 7 35 78 54 89 7 2 34 41 25 56 40 89 92 12\n 70 18 13 35 26 97 17 63 9 7 98 43 79 84 54 9 65 50 13 66 11 71 50 77 70 21 13 36 42 43 89 21 89 24 50 98 7 76 20 66 87 19 64 62 19 94 12 69 5 44 75 23 66 5 82 25 67 76 68 57 86 13 97 73 6 90 71 5 70 91 28 26 75 34 10 80 38 16 5 99 13 83 45 93 96 62 70 96 58 65 16 29 46 77 36 24 66 60 86 12\n 73 59 18 30 14 5 81 37 17 78 57 64 10 65 45 49 97 5 31 17 41 16 68 77 5 13 28 4 89 15 20 4 46 88 55 84 66 9 82 43 2 59 61 37 90 90 71 82 88 6 57 32 90 69 92 54 98 59 51 12 46 45 27 26 8 56 12 14 90 96 66 97 32 98 16 14 86 48 65 4 47 86 8 99 37 42 76 84 63 63 78 41 62 54 79 40 57 17 63 28\n 37 80 47 12 31 87 98 64 74 29 22 88 27 52 67 67 2 32 92 6 87 15 43 38 23 77 46 20 84 92 91 88 31 68 85 18 32 22 45 94 84 98 74 8 37 21 51 62 68 43 97 70 24 65 35 4 28 45 37 40 39 68 70 12 28 9 99 83 92 41 62 83 34 24 6 2 89 24 22 13 42 99 22 80 96 20 79 4 92 26 28 5 34 41 9 55 12 78 37 15\n 27 32 59 89 6 66 89 63 96 36 58 27 72 47 13 81 4 57 31 56 19 21 33 60 43 39 10 74 89 98 68 50 33 61 30 51 33 26 6 24 70 68 80 13 73 13 35 39 44 86 24 30 83 27 74 81 15 13 87 27 88 17 37 65 45 6 77 27 20 1 28 69 81 87 33 6 98 25 49 32 9 19 24 63 37 11 68 94 34 33 90 58 36 57 4 81 84 8 8 8\n 32 41 6 44 69 87 40 80 28 39 66 94 98 46 48 83 61 85 61 94 77 9 85 42 6 74 83 67 18 39 52 95 72 64 7 68 26 9 87 4 95 75 64 19 85 2 70 96 58 19 27 39 6 67 51 72 20 84 35 58 46 88 38 79 82 27 91 14 86 3 50 40 91 29 26 42 36 42 66 21 28 58 60 23 48 24 2 31 80 50 47 61 91 71 39 65 63 78 87 96\n 31 42 95 39 55 90 3 69 21 61 21 56 78 53 29 90 77 71 77 71 75 95 45 2 16 20 60 12 96 26 22 26 30 58 9 22 61 76 54 56 19 45 27 60 74 40 84 11 2 27 31 31 53 45 86 31 2 13 74 50 44 7 5 10 60 58 69 4 42 21 39 58 99 28 8 2 2 4 81 24 57 19 24 46 27 51 12 18 78 87 71 83 7 33 54 30 84 8 4 95\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 444956424 6481 6084\nprocessing times :\n 39 83 12 57 78 55 20 79 58 52 99 48 87 67 95 82 90 41 86 97 27 20 82 45 71 58 92 5 21 45 43 12 53 29 14 49 85 90 12 48 13 75 69 34 19 55 44 22 60 45 38 78 73 59 46 47 95 25 58 61 92 8 88 64 93 29 20 45 46 78 37 49 2 18 92 41 31 29 92 87 65 22 61 90 89 97 15 75 77 65 21 56 53 9 86 75 7 88 38 69\n 57 2 75 44 30 39 88 35 13 21 38 6 92 43 22 85 51 25 43 4 81 31 71 92 25 72 42 77 70 66 15 15 51 78 89 50 74 57 7 65 89 87 6 31 70 25 36 88 25 94 66 95 77 10 26 58 8 95 20 46 49 37 76 11 24 72 75 58 46 2 83 14 77 68 81 81 56 37 41 96 53 88 66 50 40 28 65 76 89 16 48 91 83 84 18 2 63 27 39 14\n 30 34 55 12 50 15 4 43 74 31 72 71 29 28 32 14 32 6 46 73 48 56 97 56 60 72 24 29 64 29 3 97 50 97 83 89 2 96 28 83 47 90 56 57 69 88 54 94 90 62 97 67 59 22 24 87 99 62 18 70 94 85 43 48 51 91 16 31 57 51 9 28 37 89 83 33 94 44 76 82 10 81 74 55 92 26 27 86 32 28 75 67 91 48 58 23 17 18 37 78\n 84 64 65 11 41 31 5 67 91 75 47 78 64 23 29 81 44 80 59 34 35 54 49 14 72 21 57 42 24 88 78 75 53 80 88 20 4 30 52 32 82 28 36 98 77 71 16 91 79 10 28 80 60 86 81 20 3 46 57 58 76 63 13 81 85 82 92 52 8 6 52 12 65 26 67 14 64 8 40 86 47 83 58 83 95 56 65 23 32 43 91 18 27 79 53 87 97 79 99 18\n 42 74 1 40 3 95 69 18 73 66 83 52 37 53 19 3 53 5 44 91 46 43 50 40 30 40 56 40 75 5 81 87 14 61 4 94 22 36 95 79 42 84 92 87 60 16 76 32 88 19 72 10 87 78 75 39 58 71 45 43 34 9 28 7 84 42 72 57 56 25 33 33 80 69 87 94 90 66 93 23 84 84 56 90 58 69 6 31 98 43 34 56 49 98 82 68 32 83 45 77\n 11 20 3 40 48 24 32 23 25 51 80 23 49 88 35 40 40 63 48 29 19 5 23 14 57 57 40 7 95 53 52 2 43 94 85 75 84 42 27 40 66 48 81 92 30 49 86 26 91 78 41 53 50 74 69 48 91 20 20 53 75 78 91 84 49 39 19 29 77 1 5 84 34 13 19 80 21 87 4 76 91 54 56 9 79 20 62 59 43 19 92 7 94 55 34 14 70 88 58 7\n 3 34 39 69 9 92 78 99 27 20 61 15 87 76 55 23 35 21 28 93 95 25 92 6 54 66 30 32 5 68 86 98 87 15 75 34 86 1 4 60 75 88 11 23 33 20 85 69 32 14 89 12 56 26 57 24 57 85 3 9 5 76 15 62 83 64 46 43 26 13 49 57 37 48 10 13 34 46 56 93 80 84 81 15 86 76 24 39 57 76 81 86 78 94 33 10 27 12 55 97\n 21 88 54 16 8 34 74 11 24 77 19 12 17 8 59 8 88 21 75 29 83 76 35 19 18 60 84 80 62 20 33 19 85 50 2 39 88 94 67 85 18 31 72 96 88 41 89 76 93 36 4 21 91 76 86 47 89 81 88 41 18 49 22 59 96 70 85 46 75 10 7 5 18 42 92 86 59 90 87 82 10 79 64 50 4 29 8 6 60 79 85 35 35 51 35 24 65 15 11 99\n 74 21 53 51 80 67 91 44 11 71 10 26 62 93 1 9 82 71 79 65 39 6 3 46 36 5 19 70 61 20 3 98 51 3 56 47 46 86 92 92 25 14 1 39 42 23 45 28 9 23 29 94 65 55 80 92 23 25 44 14 54 48 15 45 25 36 49 72 57 14 41 91 72 84 61 97 90 34 13 47 51 51 41 10 81 25 5 85 56 18 36 18 62 55 70 22 21 50 44 39\n 82 10 53 40 16 63 94 4 54 33 22 95 39 81 93 17 64 94 35 52 31 16 69 85 77 45 83 97 43 64 29 2 27 91 40 96 66 62 75 50 68 1 68 91 50 78 67 23 36 92 65 13 5 62 60 7 56 19 23 84 50 17 77 63 25 17 73 62 10 63 64 25 1 50 7 59 93 95 41 20 69 37 21 91 12 64 94 5 32 26 16 55 75 27 90 84 86 14 7 36\n 59 31 80 74 7 14 53 47 34 53 80 9 1 74 62 6 47 58 60 88 8 88 56 82 42 64 63 10 7 69 92 12 44 93 83 16 65 95 60 60 62 3 44 23 14 98 53 10 31 30 81 46 38 37 64 36 90 93 90 71 15 38 57 63 38 35 60 56 14 17 29 71 60 86 24 14 14 69 18 94 99 13 41 49 20 35 85 9 87 27 28 13 90 46 55 78 52 16 7 15\n 78 63 21 88 96 44 57 12 3 52 88 61 66 93 29 33 37 60 6 3 14 42 20 19 90 10 27 76 58 67 28 54 66 46 78 91 85 3 49 74 23 60 61 57 79 4 59 53 15 21 73 4 14 52 47 66 93 65 91 61 55 76 64 45 58 25 98 5 64 31 38 37 39 62 57 69 41 25 3 86 97 37 83 78 86 98 22 9 22 44 37 32 3 54 71 86 49 89 27 50\n 37 28 56 33 26 17 43 75 16 19 65 20 28 25 60 64 9 58 5 75 18 35 86 56 99 99 95 22 30 26 41 62 15 2 10 48 93 50 51 39 26 86 21 83 52 25 14 66 20 60 38 48 31 88 5 73 29 95 66 73 84 41 40 59 76 92 63 77 62 69 80 73 84 93 89 90 89 94 13 70 35 41 2 44 94 12 59 62 77 51 64 4 98 42 77 81 20 54 45 15\n 22 94 75 49 4 22 77 80 35 94 96 38 37 17 14 14 15 88 49 6 14 41 4 61 23 73 6 58 69 60 50 27 64 29 43 88 2 69 17 56 21 42 28 65 79 19 78 20 2 37 90 42 53 32 26 74 95 89 68 34 65 10 63 51 4 58 81 76 48 80 53 53 71 65 3 96 44 67 38 96 54 14 99 64 91 9 21 93 7 48 80 1 46 58 35 27 55 80 40 13\n 24 47 27 99 39 26 24 66 92 98 35 92 26 16 78 25 51 37 62 72 27 71 68 81 5 4 34 35 56 31 81 32 58 10 64 25 69 89 32 25 63 62 3 99 33 57 93 1 35 18 84 53 49 52 57 85 45 84 52 52 93 66 90 49 83 89 76 96 65 60 89 87 71 1 21 35 11 61 34 89 67 54 68 77 29 58 92 40 88 97 46 22 44 97 52 66 28 99 68 4\n 81 80 33 8 24 98 76 30 48 44 96 97 6 91 38 56 42 37 9 31 56 18 40 85 29 54 96 45 49 85 5 48 45 24 43 62 46 27 5 12 89 34 88 57 6 76 34 67 51 11 82 93 82 48 3 67 55 22 56 62 18 89 21 84 72 66 38 31 38 9 82 88 39 78 9 17 57 22 67 52 66 45 9 67 38 54 10 96 2 58 96 26 99 72 69 11 55 82 59 25\n 64 28 64 11 27 35 19 28 87 11 25 54 18 19 59 77 83 36 71 68 57 28 57 57 52 4 52 40 99 87 46 49 37 68 86 10 41 22 90 93 25 37 19 96 34 1 6 40 34 82 51 67 45 38 74 91 81 42 27 55 66 94 10 81 33 12 90 22 4 65 34 54 19 48 87 65 29 34 85 17 99 80 91 94 79 82 78 64 69 26 60 48 34 47 74 76 38 23 23 53\n 17 45 27 53 92 6 95 30 2 3 18 16 71 92 41 9 52 18 97 9 22 62 89 53 69 25 48 40 59 3 45 15 70 33 30 88 40 88 13 88 77 80 14 79 87 51 16 96 95 49 44 65 59 49 63 95 81 47 78 34 84 29 72 10 39 80 1 64 89 37 83 66 8 42 97 6 48 46 63 67 9 53 91 50 86 55 38 68 73 68 91 5 58 56 17 35 42 55 17 28\n 75 24 53 31 93 72 83 66 90 44 29 68 38 87 29 86 34 65 47 35 57 11 32 82 42 1 93 41 3 2 43 80 67 6 99 97 70 24 48 9 56 11 45 93 84 44 22 26 70 84 79 82 84 54 27 15 89 88 65 84 28 20 64 43 92 30 33 39 68 85 11 14 65 7 77 81 69 89 12 46 37 53 46 8 28 6 63 48 55 69 22 42 47 15 69 34 25 21 33 93\n 73 60 24 50 75 58 36 50 91 74 81 70 23 93 66 53 96 77 63 12 35 92 57 32 97 30 73 46 91 52 97 19 28 21 16 81 59 45 63 49 42 38 83 52 92 36 22 49 63 56 44 51 75 34 8 6 48 8 29 8 12 61 60 32 64 13 71 59 91 68 82 98 76 35 78 58 81 26 3 80 90 39 90 32 32 34 69 81 55 13 15 17 87 11 12 48 2 65 35 98\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 2115448041 6358 5979\nprocessing times :\n 28 25 61 9 69 77 21 40 98 65 54 75 57 49 13 31 76 94 28 42 81 97 33 5 88 29 99 77 51 39 54 90 30 54 76 65 10 70 78 29 59 16 13 29 64 69 4 1 95 16 30 40 92 77 67 93 80 88 48 7 96 33 8 40 4 55 43 73 90 68 79 50 62 47 22 54 94 23 14 60 13 22 57 23 97 11 53 3 18 66 75 51 81 90 17 6 79 71 97 76\n 54 54 63 93 38 71 28 94 46 31 11 46 35 99 30 73 60 30 7 63 43 29 96 25 73 19 65 98 93 52 62 84 27 15 17 86 18 83 69 33 8 27 43 92 33 26 68 44 78 37 81 74 75 7 23 24 21 73 27 91 8 47 65 36 87 5 91 17 82 26 89 73 90 10 63 81 1 51 65 24 22 98 93 99 72 57 67 60 2 48 72 93 75 45 41 96 20 31 94 45\n 92 47 70 22 31 11 69 72 44 64 95 99 88 83 38 13 9 92 74 28 23 33 44 77 62 59 53 13 75 67 97 25 36 85 96 77 34 24 82 39 36 13 6 8 26 2 52 41 20 53 45 70 51 83 54 62 68 43 28 28 62 56 79 15 53 70 90 86 23 94 2 73 13 59 30 47 62 22 73 22 46 81 13 38 31 83 37 59 98 21 65 8 50 27 29 1 2 19 22 42\n 60 59 50 9 17 53 7 43 61 61 80 1 37 84 47 18 41 26 89 54 5 27 80 42 46 93 13 53 33 88 40 89 89 73 9 88 94 69 72 83 60 43 87 53 10 79 59 71 65 25 36 88 37 7 11 61 66 15 47 8 50 47 4 74 4 11 69 52 17 61 29 39 67 28 22 90 51 66 58 63 43 77 93 8 29 98 98 17 56 19 53 4 98 12 65 53 23 72 7 75\n 44 12 19 86 17 49 61 81 37 10 48 9 49 49 56 44 11 86 29 71 23 15 62 73 84 93 38 60 35 83 56 61 85 40 77 67 58 41 99 96 3 36 33 8 40 43 16 75 15 81 43 88 23 1 4 10 2 39 97 11 28 27 19 6 50 3 61 52 91 53 5 64 69 99 32 43 99 29 73 14 79 54 46 33 87 28 78 27 53 11 99 45 8 64 77 29 94 16 45 30\n 27 70 48 24 73 82 14 32 50 69 98 59 45 66 66 43 17 69 66 64 90 60 31 36 25 89 5 32 48 47 73 8 51 24 51 68 97 49 32 88 59 96 45 49 73 91 4 79 35 37 42 95 84 53 27 61 79 15 64 63 83 45 14 71 89 56 55 6 74 4 90 73 34 16 10 7 14 11 52 5 50 48 43 11 99 86 70 77 39 21 27 82 42 81 72 92 58 93 61 68\n 67 15 52 36 83 78 42 27 90 11 14 97 91 50 10 64 90 27 69 23 60 7 95 56 89 14 78 48 11 16 61 76 35 32 63 33 34 4 97 34 58 59 51 7 54 8 42 94 26 69 35 19 94 26 93 88 81 2 78 31 60 44 51 99 70 3 44 30 75 35 1 99 57 18 85 16 17 62 77 62 51 6 49 45 88 97 52 57 45 20 78 21 24 32 6 54 91 73 47 58\n 74 39 70 78 72 70 29 69 94 28 38 55 75 43 82 15 55 91 96 74 30 68 14 36 74 83 43 78 48 72 64 83 61 31 16 6 72 25 85 89 68 83 14 55 97 3 16 89 14 1 6 96 8 13 32 64 67 20 37 63 63 94 97 74 23 34 8 64 99 78 11 90 61 38 30 61 76 69 97 45 38 36 3 30 26 45 85 33 11 83 97 67 76 28 15 90 12 88 9 99\n 67 23 25 92 50 8 78 46 3 44 84 21 48 15 76 11 80 82 2 84 90 8 61 53 84 2 86 91 67 86 92 95 29 24 79 30 97 9 32 35 35 40 82 17 96 36 60 88 12 76 94 78 22 74 2 99 74 51 77 61 53 29 97 28 84 87 31 2 19 33 26 22 28 25 29 6 16 51 47 26 44 83 66 78 60 22 41 66 64 3 17 78 48 56 20 36 91 95 81 98\n 58 59 41 23 18 30 39 54 9 65 72 90 31 27 28 66 5 45 31 10 67 21 25 14 9 4 8 19 64 35 53 81 93 22 26 20 61 2 97 2 47 23 27 21 36 62 29 17 3 70 14 44 73 89 71 21 90 28 36 13 85 82 57 1 72 7 25 97 90 51 28 83 91 80 9 59 27 69 2 41 81 8 24 82 35 72 76 91 18 45 83 95 29 69 14 5 92 17 93 55\n 39 18 75 33 91 20 2 91 18 6 2 40 10 48 65 67 36 83 14 84 65 1 77 35 42 99 82 26 39 18 74 75 46 88 63 25 76 85 56 24 50 43 68 42 49 93 78 43 36 51 45 72 74 36 35 41 36 3 13 24 34 34 22 17 14 17 60 44 99 64 55 67 78 12 96 13 53 70 80 52 77 17 79 51 77 99 12 13 35 20 6 6 91 66 73 88 25 16 37 58\n 10 22 6 39 59 27 42 27 3 79 34 77 92 97 27 68 29 36 21 37 24 53 26 45 99 8 53 33 24 77 78 96 71 78 4 8 11 65 68 53 6 36 73 27 72 9 18 26 16 64 37 53 87 68 64 47 72 85 89 94 31 86 1 40 21 10 72 21 97 96 15 66 51 10 55 8 22 72 23 45 90 75 42 92 57 1 44 21 52 96 24 69 76 61 59 87 81 94 50 33\n 20 29 50 6 49 95 38 34 71 50 83 45 48 65 46 24 44 76 42 51 9 56 17 39 79 27 39 62 57 56 13 32 88 18 52 73 10 63 1 58 66 25 14 31 3 85 20 89 15 50 44 3 12 73 61 34 52 37 61 27 28 24 35 26 32 48 16 30 3 69 42 14 56 45 61 58 30 31 44 51 17 94 85 3 59 54 36 42 96 69 80 26 33 2 61 47 6 95 48 44\n 96 20 20 25 82 1 3 76 37 75 73 80 59 63 51 66 90 58 24 69 7 74 48 61 33 66 25 31 1 73 89 83 87 16 56 29 22 71 92 11 29 26 82 4 38 64 90 54 6 85 58 7 94 5 6 5 71 94 59 51 6 79 30 61 83 89 96 54 85 88 46 80 19 67 8 78 58 41 51 74 70 38 24 52 17 93 95 35 22 54 31 3 34 43 20 73 87 29 51 70\n 34 62 86 58 5 41 38 84 67 62 73 77 11 10 20 93 40 80 5 37 33 70 32 15 28 99 50 86 82 85 28 68 85 98 18 51 74 79 97 19 92 87 69 42 3 12 81 97 26 77 69 67 4 68 51 49 18 24 49 73 79 81 92 57 39 15 56 36 31 60 89 64 36 72 42 19 67 78 12 57 26 28 57 74 8 30 31 36 84 82 49 35 83 69 1 69 50 9 52 99\n 87 47 11 84 54 88 83 3 39 13 33 58 46 32 87 67 52 24 18 60 71 50 68 42 41 50 31 69 10 42 29 96 27 43 31 61 45 26 7 28 63 23 33 93 67 89 75 50 65 9 56 12 36 19 50 60 69 32 17 64 64 40 31 59 82 6 26 43 34 48 68 74 86 51 43 18 27 57 59 33 21 98 96 79 91 91 89 92 30 36 28 31 25 79 45 43 80 30 29 48\n 45 25 46 38 26 37 28 68 68 17 49 85 69 49 41 29 5 87 73 52 94 56 94 44 55 41 21 3 90 32 76 20 28 32 5 57 30 70 95 75 39 26 92 10 32 53 62 35 45 27 88 35 53 13 7 74 5 77 91 77 53 74 68 39 95 32 57 48 43 9 66 15 64 45 86 56 71 62 71 78 13 73 40 4 29 83 63 90 67 18 40 98 94 84 96 81 73 54 38 36\n 62 61 2 67 9 41 30 94 17 98 49 45 16 85 39 38 13 61 52 63 83 60 46 56 70 55 75 42 62 85 51 16 31 44 58 92 23 66 88 88 96 53 1 56 37 82 24 44 15 16 15 81 56 35 27 43 65 18 91 5 72 25 3 15 62 35 7 43 57 39 8 31 42 6 5 79 56 20 85 94 94 80 58 63 60 79 26 19 4 58 67 55 79 53 39 13 34 12 28 57\n 15 94 8 91 7 47 61 40 49 43 96 84 44 89 68 95 94 54 40 30 21 49 3 17 72 84 98 23 42 16 80 30 12 65 24 7 40 70 93 49 89 17 95 33 68 97 73 8 68 54 95 6 1 43 19 48 38 17 50 97 76 41 98 94 77 9 81 53 75 40 48 30 49 66 56 39 68 69 32 70 49 70 54 60 28 39 71 68 95 72 21 46 17 85 92 79 57 7 81 73\n 29 41 93 48 35 75 36 8 49 51 22 83 54 59 61 34 45 4 87 61 96 9 99 39 83 14 37 86 49 84 21 78 93 5 14 23 73 76 79 22 94 68 39 50 31 30 38 43 40 56 31 23 85 94 55 94 78 81 34 77 77 56 47 3 65 17 21 81 72 30 44 13 90 77 22 75 87 24 83 21 41 22 40 33 73 33 41 5 47 69 1 80 9 88 91 16 65 4 85 6\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 20 118254244 6465 6298\nprocessing times :\n 50 69 14 61 88 5 52 87 92 78 25 40 79 79 24 91 3 19 91 27 29 90 63 28 93 24 63 52 45 64 61 96 35 19 78 27 57 17 80 31 65 29 36 73 51 14 8 65 95 84 49 70 89 57 52 11 32 54 70 76 52 50 84 27 6 44 50 89 87 14 96 30 82 75 55 90 6 63 37 40 2 71 2 17 17 94 36 47 89 37 6 56 79 62 82 83 98 49 43 23\n 43 66 85 81 68 48 63 73 92 63 42 72 71 46 56 79 59 55 91 25 47 82 54 64 45 33 9 84 94 83 19 95 81 41 12 62 99 77 21 36 56 48 18 97 87 33 85 42 60 71 36 29 69 59 83 37 55 85 77 1 76 69 81 67 62 95 15 78 88 82 61 58 92 15 17 66 22 21 90 67 49 57 58 86 60 94 65 40 4 9 39 51 64 9 48 57 61 61 92 2\n 2 38 79 78 8 87 75 53 96 27 25 41 99 25 16 27 92 37 74 78 93 73 66 16 18 67 10 3 75 35 42 11 81 37 62 44 60 13 76 8 16 98 36 13 36 40 59 61 69 53 30 47 2 38 39 24 47 89 46 56 90 36 26 23 36 54 57 35 33 5 74 93 5 79 37 56 43 93 36 92 86 84 87 94 45 48 54 15 92 27 84 41 13 98 97 29 99 97 63 36\n 37 31 36 73 88 9 51 24 65 99 22 34 44 43 53 44 10 79 73 30 5 49 32 87 85 84 67 16 91 94 61 36 61 21 16 57 29 53 59 43 98 89 17 22 67 86 44 1 36 4 59 28 43 32 58 69 76 49 48 90 41 21 65 7 83 12 72 27 58 20 92 63 27 27 96 1 9 75 85 75 18 22 84 16 79 50 47 78 93 56 96 6 41 78 30 90 58 60 38 71\n 66 46 31 21 54 71 42 81 8 32 12 41 12 71 31 60 25 18 81 7 55 33 41 34 32 75 69 57 79 61 93 98 74 76 80 49 93 9 68 96 93 66 60 36 79 6 59 3 44 7 72 12 69 50 41 75 48 48 92 8 83 31 66 5 64 59 10 97 86 6 34 79 32 88 98 44 49 66 61 46 21 40 6 93 65 57 43 58 54 36 72 37 21 51 19 29 92 3 86 77\n 3 3 42 46 84 38 92 86 93 22 26 93 64 32 75 63 5 55 14 63 71 8 6 3 46 65 5 74 30 49 25 95 43 12 14 83 90 10 40 33 48 52 78 26 76 34 20 32 42 88 36 78 6 59 89 48 47 68 86 75 18 61 49 20 65 55 5 9 1 84 37 75 16 46 44 72 81 79 6 4 84 27 14 88 9 38 18 88 69 28 20 52 11 44 96 45 38 71 9 32\n 14 68 51 62 67 21 94 64 43 12 1 86 84 87 80 38 15 4 13 46 20 27 28 83 18 41 3 45 91 18 57 84 28 31 74 98 14 2 90 59 23 17 82 21 83 79 24 23 35 39 19 84 55 7 37 62 25 90 78 49 21 27 90 52 18 95 38 82 76 99 43 5 19 73 45 82 55 93 9 74 9 5 12 65 86 35 61 43 3 11 98 94 61 87 59 9 48 61 61 51\n 7 95 72 16 15 69 4 31 16 26 15 28 24 55 19 15 20 63 43 76 57 74 81 74 88 26 72 23 84 3 6 68 8 69 57 41 44 54 24 92 23 66 65 54 44 18 62 71 33 97 17 9 15 43 85 85 39 92 55 3 85 49 76 91 17 30 66 22 21 75 59 52 83 32 49 47 60 42 90 81 94 78 22 22 83 82 87 2 66 44 36 78 28 89 51 8 57 49 86 82\n 53 63 79 98 11 89 22 50 86 84 56 32 4 87 58 3 99 81 51 35 41 37 21 26 50 50 65 8 62 7 83 3 90 64 46 96 69 59 26 57 89 3 20 33 75 54 36 37 64 34 32 1 51 6 57 48 27 28 13 91 71 76 26 16 27 76 65 82 57 25 72 7 8 73 59 26 34 18 78 67 93 99 33 8 32 71 70 84 26 59 55 46 57 53 44 63 83 55 4 20\n 96 28 67 99 97 35 26 61 11 95 3 24 65 76 58 19 42 28 7 48 16 23 7 13 91 99 99 21 67 31 61 22 77 70 29 32 24 79 22 61 53 31 73 20 5 16 34 5 50 73 93 32 71 45 10 66 36 53 98 80 97 19 39 93 47 3 64 12 68 28 14 4 1 67 8 61 23 14 58 75 50 64 17 70 40 75 88 65 62 54 61 98 29 14 2 11 78 65 63 59\n 30 34 90 42 56 24 36 4 79 60 74 94 53 74 54 48 80 71 91 37 32 59 82 39 98 75 55 59 45 96 28 78 64 93 5 29 73 68 42 63 14 37 63 39 40 25 74 6 85 76 7 54 27 6 83 80 62 4 59 68 27 85 37 19 53 11 13 64 80 52 17 79 76 33 21 7 69 19 6 65 7 88 86 98 2 62 64 40 17 33 93 40 58 82 20 60 48 6 61 35\n 57 11 72 35 66 56 36 16 96 97 59 65 87 12 13 5 6 55 95 82 55 16 56 49 33 44 8 23 83 8 73 4 73 85 37 17 46 22 44 95 80 38 7 51 26 74 90 13 13 70 95 83 47 23 34 26 64 9 31 51 87 91 35 21 70 48 31 98 97 8 9 41 13 83 81 50 66 42 81 26 59 6 4 22 63 31 54 49 13 79 17 53 3 44 85 7 69 57 74 50\n 64 13 43 55 58 8 82 37 76 90 42 35 10 15 21 47 30 12 83 2 27 80 13 10 30 18 29 65 80 71 64 59 21 46 47 89 69 81 24 29 77 68 55 9 20 13 21 79 96 33 87 91 60 42 48 59 98 54 97 99 44 93 74 91 94 30 52 17 96 44 46 87 97 9 18 18 77 47 26 74 97 47 81 59 11 94 90 23 78 86 15 45 27 22 3 50 76 90 99 52\n 70 86 95 81 48 38 1 97 24 69 61 84 46 92 12 97 65 14 90 80 33 47 59 81 90 72 50 9 89 54 26 35 60 38 21 55 70 79 23 92 7 59 49 25 50 9 16 79 30 96 96 98 56 95 44 90 5 51 47 69 60 43 18 92 82 27 74 76 57 96 96 9 16 12 88 59 39 42 76 17 35 65 87 96 35 93 61 15 86 9 39 64 3 90 25 17 3 94 9 76\n 65 75 38 51 65 87 86 35 58 65 72 24 70 41 73 41 80 14 69 23 33 70 99 75 50 83 67 97 48 38 99 21 17 97 8 69 63 71 80 93 27 30 48 31 36 2 94 87 52 62 85 35 1 76 35 27 6 64 6 79 23 33 17 1 9 29 49 20 50 7 46 86 3 15 7 76 97 89 93 92 58 23 93 54 14 33 82 88 3 73 18 85 22 90 87 97 1 89 98 7\n 92 1 39 97 92 59 60 1 78 3 65 80 98 76 40 58 36 23 22 21 48 47 14 91 86 66 50 6 33 74 44 20 58 20 82 98 63 33 61 93 8 18 95 57 8 93 88 6 94 31 99 69 22 83 5 50 2 39 53 39 98 33 7 54 71 21 5 13 70 57 27 38 55 93 12 66 16 31 1 42 26 96 14 57 34 43 73 68 19 12 23 92 95 24 16 66 81 55 52 79\n 28 48 54 78 29 29 63 15 12 48 22 39 83 15 73 89 27 23 11 8 52 83 4 84 52 58 91 47 13 27 10 94 85 46 97 47 57 51 3 61 91 26 78 45 33 31 94 4 37 83 54 68 32 94 4 48 36 77 6 89 61 65 91 78 39 73 20 92 66 92 30 90 62 86 98 17 30 53 56 32 52 19 1 33 75 22 97 47 6 58 45 94 6 4 83 55 10 72 25 12\n 39 60 80 99 48 97 28 84 11 98 37 93 4 73 61 84 16 80 14 70 69 95 13 28 67 68 35 10 79 2 10 56 77 96 74 12 94 14 68 86 68 6 14 70 87 8 22 64 61 23 93 10 28 84 44 21 2 24 79 91 30 93 41 49 28 13 43 29 45 22 91 74 25 99 40 3 85 70 42 1 28 48 94 63 2 89 68 21 84 37 15 54 2 70 77 86 83 54 45 27\n 75 81 18 12 29 83 78 16 73 38 18 43 38 83 83 6 45 91 39 77 5 94 89 79 81 94 62 25 17 6 19 89 65 5 54 14 96 77 1 88 16 93 35 91 1 66 68 10 33 37 42 29 16 84 15 83 42 28 7 40 28 59 63 10 4 6 90 98 12 76 35 14 43 72 3 94 28 31 75 55 79 37 68 97 4 51 72 87 47 55 2 92 28 27 40 94 39 82 90 32\n 16 60 31 34 94 94 18 30 84 95 37 80 37 31 26 30 32 49 33 30 96 74 81 24 28 48 78 50 8 86 81 17 5 27 41 73 98 23 24 21 5 66 4 7 68 85 34 69 5 24 3 91 18 61 36 68 68 1 9 35 54 18 38 19 82 43 60 43 46 91 66 52 53 9 45 67 38 48 21 7 11 19 85 7 56 79 54 45 9 33 61 39 19 8 85 86 80 57 38 62\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j100_m5.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 896678084 5493 5437\nprocessing times :\n 73 84 57 52 66 67 33 62 65 7 6 31 42 82 48 45 79 86 10 47 67 86 64 38 13 69 4 21 25 74 11 85 50 21 93 98 91 26 4 28 61 8 55 68 30 26 81 95 49 6 82 71 61 84 29 44 83 12 54 19 52 59 74 42 60 43 80 34 74 46 40 27 79 1 98 44 8 55 55 27 69 79 97 39 54 75 88 87 97 4 79 59 7 89 61 42 79 85 66 99\n 34 46 97 88 52 49 88 15 55 6 77 49 46 14 35 40 1 70 46 28 73 24 44 55 94 52 40 76 92 22 46 19 18 50 31 41 51 73 22 21 79 93 98 89 44 64 93 66 14 10 36 36 69 79 90 51 81 16 28 26 97 33 77 68 28 46 16 96 59 56 4 52 89 84 42 37 90 51 84 16 39 16 37 19 15 68 7 58 47 27 82 72 1 7 22 40 59 16 7 72\n 8 37 38 30 20 68 4 78 41 2 62 38 95 82 96 56 61 34 1 9 57 80 58 7 56 31 92 84 25 20 65 36 67 96 35 59 76 66 83 37 33 2 95 20 84 43 4 44 74 92 55 98 8 30 18 28 54 68 42 28 12 57 81 19 16 88 75 11 57 99 4 51 26 6 16 71 52 96 89 79 91 57 2 33 42 1 40 76 85 99 65 98 78 61 83 30 14 62 41 91\n 62 86 46 3 22 33 90 94 98 9 84 69 26 22 49 90 81 12 54 53 18 56 43 50 82 18 89 49 20 76 90 64 89 16 3 12 45 67 97 80 97 92 56 50 95 25 52 21 47 4 67 62 63 25 3 55 87 84 28 73 8 38 80 53 70 9 87 33 11 65 92 34 64 96 67 54 26 32 10 91 90 31 7 6 77 91 42 5 46 54 56 1 24 62 47 63 39 63 95 45\n 10 60 34 96 79 62 6 15 94 39 85 17 55 59 48 11 63 98 33 49 41 82 12 61 94 80 84 18 68 6 98 47 6 55 73 70 56 46 50 90 89 88 50 99 41 36 16 84 98 44 42 43 62 49 22 16 14 55 45 20 35 89 7 64 36 5 63 8 76 95 40 51 98 77 92 35 3 56 1 17 70 45 87 37 70 84 69 7 5 97 47 12 54 84 49 89 86 37 52 85\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 1179439976 5268 5208\nprocessing times :\n 73 69 8 59 70 47 2 37 60 75 7 41 87 21 55 32 45 56 92 2 69 39 52 2 4 79 55 20 46 88 47 63 55 90 29 79 33 40 21 4 31 99 74 93 17 5 76 49 65 80 42 45 35 13 57 46 54 7 58 3 51 86 21 47 91 48 21 36 23 50 86 84 88 84 31 63 16 55 12 14 74 59 21 91 24 69 49 4 81 35 82 12 71 6 59 95 13 40 12 43\n 5 87 54 84 8 37 40 27 81 64 80 23 66 64 19 38 96 56 16 61 48 42 28 52 78 57 28 83 36 36 28 92 6 1 89 31 36 88 74 50 85 34 37 91 11 32 83 40 86 33 58 75 85 42 71 76 59 29 57 98 47 38 98 87 25 1 60 71 18 80 41 59 89 29 54 38 80 12 56 25 85 76 33 35 61 4 70 54 69 22 47 25 42 80 43 32 85 11 72 17\n 62 94 58 93 23 66 47 30 60 26 84 54 82 60 13 14 23 80 56 31 65 83 52 92 74 12 65 37 9 78 40 13 10 23 50 86 81 67 20 34 78 9 3 96 84 2 46 71 79 44 89 67 34 20 88 53 94 85 2 2 35 98 33 33 1 46 7 19 4 40 33 94 75 85 33 15 10 72 24 81 53 27 23 80 99 15 85 4 2 67 72 78 25 31 63 57 36 72 73 87\n 42 59 91 86 76 26 78 51 39 10 95 83 40 83 20 7 23 62 42 75 84 95 77 32 17 43 53 15 49 64 76 86 12 54 62 30 22 53 61 53 71 24 55 93 47 96 51 84 94 93 16 15 21 78 77 25 43 26 54 91 82 50 65 84 21 67 96 72 14 74 77 37 18 81 92 23 29 43 3 5 19 62 33 53 51 35 96 57 29 26 18 36 19 93 69 39 79 15 13 7\n 86 73 89 81 10 84 98 76 18 25 77 70 33 31 41 55 35 68 19 28 74 60 81 82 34 38 92 90 95 83 8 44 48 65 79 82 56 49 25 88 52 76 36 24 35 29 9 40 65 35 54 14 5 91 24 39 1 58 88 1 12 49 69 71 35 70 64 20 15 7 73 20 20 99 16 53 33 94 14 89 52 41 12 78 40 93 35 10 94 88 84 53 72 60 59 63 24 41 8 73\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 1122278347 5175 5130\nprocessing times :\n 37 45 97 90 54 69 12 29 47 21 60 45 5 6 41 38 35 69 74 83 31 39 17 29 17 50 58 8 56 27 88 7 89 98 69 73 22 82 85 48 18 6 3 19 12 57 34 83 71 94 30 54 39 32 11 64 39 45 39 41 8 34 53 84 56 48 63 29 79 22 67 89 81 25 32 70 15 45 38 58 35 50 56 41 81 40 94 51 33 13 70 26 34 11 29 87 1 43 12 52\n 54 85 52 79 78 16 92 82 28 2 48 34 48 20 81 44 12 40 15 86 61 59 21 71 22 35 81 41 53 18 12 24 16 52 93 44 86 9 83 37 42 46 13 28 95 23 67 59 75 90 66 88 68 50 30 70 18 53 1 34 82 41 84 64 66 97 71 17 37 29 24 97 6 83 40 36 67 53 68 20 36 30 95 92 57 75 92 94 28 65 9 23 30 63 86 30 61 28 92 10\n 28 1 75 36 27 19 62 76 78 70 24 12 23 44 84 50 96 15 60 41 64 54 28 94 73 64 64 63 67 12 51 56 78 34 43 71 61 4 17 36 38 60 79 66 28 84 95 43 23 51 30 60 31 34 1 46 84 22 57 16 39 49 71 41 3 72 24 26 80 72 61 66 72 65 93 74 21 82 87 76 80 31 20 90 68 31 31 11 22 66 69 61 94 1 23 48 45 92 40 69\n 11 5 37 55 55 83 62 58 75 57 27 29 55 71 41 11 14 78 79 69 88 54 78 10 27 43 76 9 70 98 9 83 66 32 25 7 60 5 15 28 27 23 31 96 74 60 19 38 37 56 37 61 75 72 8 54 27 52 84 37 50 63 64 31 45 88 22 16 61 82 47 63 99 53 31 41 88 37 23 59 84 3 77 90 10 16 57 25 49 13 50 97 59 59 70 15 26 68 79 49\n 65 64 94 90 33 41 24 24 10 47 21 83 14 81 86 82 7 36 33 62 2 48 12 88 82 28 34 3 99 70 60 50 35 38 83 22 69 44 9 89 47 14 24 14 33 70 99 15 96 23 27 15 37 99 8 41 41 43 66 16 37 97 86 16 46 34 85 59 29 29 30 51 49 72 69 51 11 98 63 80 81 86 55 74 43 93 98 24 62 50 68 65 69 17 49 29 70 46 53 66\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 416756875 5014 4963\nprocessing times :\n 69 53 81 70 96 25 24 95 30 40 37 5 88 74 95 26 96 3 44 3 8 44 13 92 2 69 48 23 96 92 56 15 47 41 96 35 56 34 80 73 96 81 32 55 22 43 26 20 53 63 33 47 93 68 8 51 18 80 17 88 72 97 36 58 35 56 13 73 5 12 12 17 21 44 34 61 99 54 18 2 13 17 60 90 36 52 88 56 34 97 80 8 84 17 43 30 19 38 76 88\n 78 26 41 62 28 54 27 38 64 66 82 78 52 18 1 54 43 48 67 8 36 38 32 74 96 34 56 28 66 93 51 28 63 84 25 85 1 42 12 42 23 85 77 7 43 84 76 85 29 96 3 44 88 17 44 17 35 16 2 16 68 40 76 33 92 70 6 53 57 47 41 50 97 66 33 96 4 12 26 89 29 10 15 59 54 92 39 52 95 4 35 42 19 74 45 7 60 29 48 76\n 28 54 66 30 77 69 50 85 62 80 58 77 55 80 94 6 22 33 66 55 57 49 82 75 91 14 72 72 77 83 27 61 57 78 23 60 33 49 63 25 87 36 18 70 8 68 50 89 5 28 5 27 51 53 20 48 45 61 73 32 44 35 81 75 21 8 20 86 64 56 86 87 9 58 78 39 15 25 43 10 83 32 5 49 23 12 56 35 34 66 31 54 6 37 69 1 92 63 28 50\n 55 57 50 42 18 95 68 22 33 15 4 66 50 6 81 45 61 33 53 69 3 61 40 72 28 42 69 42 73 46 75 75 35 75 1 74 3 13 66 51 72 9 45 73 32 19 98 93 27 8 55 7 89 36 41 35 35 36 13 85 21 33 33 21 3 10 51 81 65 29 15 60 60 87 87 36 19 73 57 27 14 49 49 37 37 83 86 13 10 44 42 98 3 99 21 19 71 65 96 36\n 39 81 33 63 60 73 61 74 8 49 93 90 37 18 55 6 3 80 65 37 12 17 21 59 60 94 24 19 81 54 9 49 41 41 85 56 49 6 81 60 76 1 30 84 46 2 64 76 75 49 37 44 80 47 35 15 9 31 63 14 13 55 16 42 18 52 63 28 65 73 72 62 31 97 67 17 69 11 46 39 65 89 69 24 3 62 97 46 44 89 47 90 59 41 13 23 16 45 42 96\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 267829958 5250 5195\nprocessing times :\n 14 28 71 57 82 68 58 61 84 7 31 12 75 91 47 53 35 89 64 67 1 70 52 31 74 37 83 21 28 46 79 95 27 71 24 99 7 68 35 83 36 89 79 64 51 97 3 9 94 45 17 56 58 49 32 49 26 53 67 31 72 71 93 23 42 79 19 43 26 71 17 37 93 11 21 79 51 26 85 41 76 28 76 40 83 18 74 8 75 66 50 16 14 12 98 71 47 22 71 44\n 21 16 40 45 1 97 17 65 51 35 22 27 78 23 46 6 85 29 63 7 5 9 99 31 83 74 31 76 66 73 79 48 69 81 89 75 74 8 62 36 24 86 94 67 85 39 43 92 87 23 1 19 49 32 75 74 19 25 5 75 71 80 72 60 64 36 23 7 52 8 87 5 44 37 66 74 6 44 30 78 99 34 77 51 57 68 27 36 36 70 66 79 74 63 47 40 28 44 30 48\n 3 24 75 31 52 53 73 3 60 26 43 69 65 58 40 46 54 40 72 71 91 74 44 25 18 83 99 9 52 75 88 58 21 72 95 73 72 64 82 91 13 98 38 44 94 47 49 32 81 54 21 52 99 83 3 30 57 54 74 29 45 97 3 55 81 47 71 37 98 48 96 11 48 5 65 2 40 29 23 96 11 55 33 44 67 22 33 96 90 69 11 23 37 30 6 66 94 19 18 57\n 9 18 42 29 30 60 56 30 73 44 42 10 48 96 95 65 3 31 39 92 71 24 75 11 63 40 40 74 37 8 88 90 30 62 60 3 40 79 38 97 13 23 99 43 99 92 74 97 42 21 73 90 16 45 97 7 47 33 77 91 10 22 22 3 82 4 57 21 97 58 27 25 38 49 13 68 43 60 25 63 48 13 36 71 27 14 11 87 27 6 63 61 55 62 34 17 11 28 46 63\n 6 52 73 71 48 53 68 72 91 74 35 34 41 86 86 19 49 11 60 25 73 25 44 45 51 68 25 12 53 73 24 39 47 45 35 69 32 94 4 6 99 93 30 24 72 9 72 78 37 18 79 20 40 89 81 86 28 21 94 53 53 46 31 84 79 91 87 45 23 59 75 52 45 21 59 21 9 61 6 58 71 69 2 50 55 92 29 2 94 57 36 74 87 32 76 86 22 29 90 44\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 1835213917 5135 5063\nprocessing times :\n 7 41 6 14 62 1 40 16 76 75 80 73 73 38 66 64 5 47 26 54 48 54 76 1 57 89 39 20 16 40 5 94 53 12 64 83 22 78 20 93 89 41 77 81 57 95 12 83 31 19 66 73 79 21 91 48 17 76 59 79 12 88 91 60 8 95 59 41 56 20 70 16 4 13 40 64 88 92 95 14 16 2 21 97 59 87 70 11 98 75 28 51 27 58 19 64 5 82 12 55\n 62 67 30 5 26 57 28 5 41 81 44 93 45 20 50 55 87 90 36 15 14 24 42 53 92 39 55 77 40 66 42 19 54 79 64 66 71 89 72 13 67 72 46 69 82 94 26 50 11 58 11 89 23 29 53 42 37 96 58 41 6 49 34 86 77 92 98 65 1 18 70 27 46 95 70 12 41 4 44 32 70 27 22 57 31 20 86 30 27 47 90 47 41 47 29 12 14 1 42 67\n 29 39 31 3 50 37 85 70 22 35 59 61 65 88 28 35 69 22 89 21 25 66 88 90 55 65 58 55 2 92 72 22 6 26 65 36 14 97 75 13 81 27 85 16 12 29 21 63 23 74 25 92 73 5 73 1 36 7 11 95 24 59 71 71 69 67 28 55 66 48 46 39 6 20 72 70 61 83 79 82 62 91 8 88 25 9 34 20 93 7 13 11 57 27 7 44 99 51 88 17\n 10 54 89 9 52 47 5 39 31 93 56 44 60 79 91 17 23 76 46 30 43 54 44 84 56 9 25 56 15 27 98 81 99 77 72 5 21 8 11 73 34 17 80 1 42 3 59 32 49 12 26 61 15 20 24 77 40 75 83 50 82 91 78 88 16 60 23 18 29 45 26 66 73 90 91 68 15 26 11 22 62 96 52 72 17 48 49 99 80 30 6 33 89 12 80 94 52 41 49 93\n 30 10 54 3 63 63 90 60 88 36 92 1 90 23 49 96 95 46 23 91 50 82 13 77 51 4 32 90 4 73 21 10 58 54 76 12 89 23 7 89 97 70 67 81 91 51 47 73 76 74 13 11 5 28 56 37 3 15 95 94 25 56 79 5 33 45 42 74 9 31 42 45 72 87 37 19 10 25 38 59 58 96 36 86 93 38 47 73 18 10 71 30 99 82 11 45 79 67 35 23\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 1328833962 5246 5198\nprocessing times :\n 94 17 1 97 91 9 75 38 34 17 7 62 16 61 31 58 14 29 29 31 52 36 85 68 63 21 15 50 55 73 87 90 41 80 5 18 68 94 51 29 12 69 54 99 1 82 99 87 61 24 54 7 77 78 86 83 65 77 98 33 92 15 59 22 79 44 99 19 32 81 57 53 48 97 3 70 21 51 14 41 91 75 35 54 9 25 27 97 20 20 23 46 76 34 86 30 99 9 91 81\n 65 67 55 35 19 18 35 39 89 57 79 5 33 46 47 46 99 39 7 15 56 32 62 50 99 89 30 24 23 44 83 13 83 73 34 89 18 32 90 73 28 18 81 31 2 3 78 99 71 8 88 76 33 66 3 31 8 63 53 89 63 49 60 53 70 9 16 79 93 69 4 95 87 49 79 14 4 20 10 28 4 91 63 66 25 12 36 94 19 49 19 18 18 53 49 29 42 59 48 3\n 51 20 55 55 15 46 15 60 40 67 46 29 14 35 81 8 55 55 1 62 97 93 58 46 92 62 58 1 18 14 74 29 85 95 11 30 73 24 83 15 77 63 43 40 98 17 89 18 54 33 66 97 61 51 2 51 72 33 46 83 17 16 93 63 39 55 28 78 68 76 48 64 87 26 14 48 78 82 33 22 45 49 90 82 73 70 95 99 64 97 73 44 68 88 21 58 25 1 27 15\n 32 11 34 47 33 7 18 69 95 95 71 27 24 32 1 42 82 95 90 28 36 6 83 17 30 96 32 3 64 67 7 92 50 90 40 96 96 18 92 29 85 39 75 61 10 99 21 85 54 33 52 96 64 22 2 85 49 82 91 13 62 56 63 53 88 95 71 75 21 18 59 17 11 80 51 31 77 84 20 16 19 16 73 12 97 92 65 52 22 62 26 41 56 32 54 60 85 66 10 37\n 15 53 87 5 21 32 53 27 14 29 30 76 58 28 29 43 25 35 83 22 3 10 73 47 87 50 74 7 89 89 72 9 34 7 32 82 77 64 13 55 81 55 37 43 99 39 25 17 13 65 60 70 22 62 37 95 87 18 31 75 23 48 18 5 63 1 25 6 29 27 10 29 53 87 39 46 18 44 24 86 65 45 52 95 22 97 71 31 46 54 59 90 72 65 84 20 17 51 57 72\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 1418570761 5106 5038\nprocessing times :\n 26 23 92 67 41 58 3 3 37 69 91 20 40 14 31 36 51 87 47 74 49 21 47 39 80 2 7 98 23 17 26 19 94 33 18 94 68 68 18 16 94 24 67 14 39 29 73 64 9 82 36 44 33 65 10 1 26 53 65 22 64 74 76 13 68 93 15 74 32 74 50 25 30 9 41 35 19 89 42 2 59 27 7 53 43 40 53 67 98 33 16 5 53 39 60 52 28 20 84 93\n 51 52 40 67 87 4 78 50 87 81 29 25 64 79 73 91 5 32 78 14 12 74 21 79 30 3 73 90 4 1 60 37 86 96 85 54 75 77 88 73 1 1 7 27 86 65 11 36 38 99 17 23 44 32 84 12 60 74 16 90 68 44 99 95 65 63 78 61 67 10 91 81 38 35 65 14 80 42 58 52 95 30 45 6 31 11 5 47 35 56 4 85 40 99 61 9 9 13 15 67\n 23 10 85 83 27 42 87 84 1 45 65 2 86 26 14 43 58 40 43 82 25 21 66 93 32 63 65 77 40 78 76 65 74 59 48 7 89 82 89 44 70 7 92 87 44 34 25 49 68 21 86 61 4 32 9 64 47 28 55 47 54 8 89 8 36 88 14 2 17 51 25 39 73 45 70 50 87 95 7 21 57 46 5 98 62 39 30 35 87 7 49 60 72 86 4 54 24 31 86 9\n 59 60 61 68 72 12 46 27 45 60 31 99 34 25 43 96 58 40 63 62 17 74 99 16 13 64 47 47 36 39 57 82 22 17 17 9 11 96 14 2 25 8 68 89 10 18 64 79 71 16 95 24 30 59 93 8 97 98 45 82 81 75 31 59 25 23 71 64 88 21 78 67 8 37 24 96 26 62 88 68 63 41 82 86 9 40 12 93 13 37 70 95 76 30 1 60 89 48 39 8\n 22 34 10 54 6 8 29 6 60 97 97 82 59 39 4 16 46 84 27 60 86 9 91 75 26 37 17 21 41 31 47 49 20 47 32 4 77 44 90 1 3 34 35 69 46 85 85 51 62 98 72 62 18 97 36 31 94 68 79 85 14 91 73 26 53 1 43 85 77 79 78 26 75 52 25 21 95 23 80 77 84 4 76 30 91 41 51 68 67 8 66 53 60 76 13 90 5 1 47 78\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 161033112 5454 5385\nprocessing times :\n 31 37 48 7 22 18 95 98 21 79 99 81 65 55 46 56 93 88 43 52 68 11 69 27 65 85 55 49 3 53 25 29 33 35 56 89 36 50 30 9 53 29 26 55 62 93 31 13 62 76 41 82 1 1 65 65 23 33 7 14 74 81 60 35 73 83 24 42 61 9 67 55 58 48 38 55 30 76 47 4 3 57 32 62 61 72 67 59 57 80 97 73 75 58 74 32 87 6 47 65\n 28 1 98 12 29 18 31 93 13 84 26 27 94 60 91 23 35 52 28 87 8 95 8 47 75 99 85 50 15 75 64 41 49 16 40 64 65 64 26 87 89 55 43 11 83 75 14 52 86 14 10 45 90 46 49 55 27 70 71 69 62 90 30 91 76 55 68 77 77 1 48 34 48 59 5 74 77 4 93 87 74 81 29 6 18 16 84 75 80 38 34 11 13 84 17 53 19 93 71 66\n 55 91 82 92 84 54 60 21 32 11 26 60 71 94 85 25 10 16 23 21 14 65 75 24 46 54 69 28 93 76 82 71 63 85 16 22 81 43 96 8 50 78 71 46 81 95 6 36 17 46 54 10 82 91 30 93 15 17 34 19 14 45 4 64 14 3 65 69 48 2 51 7 13 70 76 91 87 96 14 31 78 22 50 36 86 83 32 54 98 21 94 72 66 96 2 26 4 54 25 27\n 71 85 53 10 54 61 86 11 79 15 47 54 78 54 44 69 40 95 35 78 62 93 70 8 84 43 59 44 30 77 77 34 80 37 88 9 73 98 13 19 53 88 39 23 11 17 6 3 1 74 87 77 25 26 13 3 78 45 29 7 60 62 61 95 39 53 78 6 25 10 71 7 28 96 42 63 98 35 93 60 89 84 80 8 59 53 58 64 88 66 72 72 81 11 75 90 90 42 96 7\n 32 28 73 30 72 56 83 21 33 40 51 73 15 87 12 69 7 2 91 70 26 16 82 16 97 99 28 56 29 67 69 68 78 87 73 87 98 28 60 54 99 52 7 68 40 27 12 49 60 61 48 49 31 58 92 16 57 42 82 46 35 94 33 85 71 70 87 43 23 28 79 13 89 45 75 85 86 34 20 47 11 14 30 81 29 64 73 94 29 8 84 33 18 95 70 85 15 93 62 74\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 100 5 304212574 5328 5272\nprocessing times :\n 88 11 99 20 63 67 79 91 13 77 13 52 84 73 61 27 67 5 3 13 89 58 55 1 79 74 14 71 13 60 1 55 75 88 78 80 15 93 98 40 27 65 65 70 63 54 42 82 94 4 34 91 50 50 11 3 38 50 90 97 79 45 20 22 51 83 60 50 3 1 13 63 67 19 21 89 83 60 83 67 71 60 25 26 82 60 54 26 97 30 21 71 12 13 47 95 90 67 61 23\n 43 9 81 83 90 44 60 70 85 11 88 44 97 96 28 93 28 95 94 6 52 23 33 2 60 42 59 45 5 76 45 26 44 47 11 81 82 68 6 87 20 32 35 7 61 4 71 70 11 49 54 63 91 79 5 81 99 4 10 19 24 15 66 48 96 4 82 74 21 69 83 64 22 1 7 34 93 70 31 86 74 71 5 45 76 99 41 28 80 54 99 12 57 13 46 97 90 59 65 82\n 2 10 40 22 98 85 11 94 49 57 47 65 22 21 18 72 72 25 41 31 82 91 57 89 51 5 4 30 26 78 53 43 58 92 80 64 6 70 94 34 98 28 64 62 43 47 6 11 43 22 41 83 43 48 65 85 15 86 90 59 81 17 83 61 2 83 37 57 85 4 55 23 78 62 83 69 27 94 55 20 19 48 34 90 62 90 93 97 86 22 69 18 89 75 80 35 21 7 68 47\n 95 10 84 34 26 76 32 50 44 36 18 25 28 81 57 48 79 14 88 8 85 69 60 74 66 7 24 92 57 85 54 33 86 61 16 33 14 5 85 83 94 46 67 74 81 10 9 75 70 92 25 97 45 23 84 20 26 54 82 20 55 2 62 93 5 14 65 16 27 34 80 62 37 28 4 28 92 64 10 30 6 58 77 53 50 99 19 20 69 15 19 30 35 90 50 52 49 73 73 19\n 20 5 96 32 33 79 35 4 22 13 64 9 55 92 85 20 86 57 49 61 50 26 16 87 32 49 27 9 92 93 43 62 19 27 2 82 61 10 43 94 59 56 82 17 42 34 29 80 32 14 49 53 43 31 22 97 91 10 95 72 10 36 87 76 10 70 12 11 81 50 97 96 84 8 18 40 84 98 91 71 81 83 47 82 1 63 31 22 59 96 19 56 91 64 52 97 56 17 18 15\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j200_m10.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 471503978 10868 10816\nprocessing times :\n 17 37 22 71 79 37 69 53 59 64 11 67 27 64 59 31 43 42 56 88 71 86 6 54 92 75 83 2 60 62 83 73 55 3 71 34 40 13 62 56 28 53 71 5 73 95 23 49 17 81 88 62 35 78 90 36 46 98 75 36 74 86 67 87 68 1 87 87 7 34 1 91 7 6 46 3 45 55 92 67 13 30 27 19 51 86 20 95 79 48 83 91 78 41 61 90 57 4 21 68 87 62 69 79 69 35 25 68 14 9 74 61 58 81 52 93 44 57 89 81 69 98 78 70 3 70 62 81 61 65 65 33 62 19 57 82 78 94 65 14 9 29 70 90 86 12 40 12 64 32 18 11 40 14 22 49 95 82 7 19 95 39 71 34 89 63 85 60 91 49 46 10 19 50 65 41 58 62 45 67 64 6 77 94 24 38 73 59 61 14 59 83 3 46 16 56 40 7 79 55\n 30 26 2 29 98 67 92 51 53 82 86 47 36 23 34 66 43 71 31 36 41 6 28 43 18 64 28 13 7 13 93 93 56 72 71 28 95 96 55 58 66 3 77 80 2 82 86 16 29 24 89 96 99 15 49 78 48 64 3 63 14 95 88 9 61 24 38 50 47 42 30 97 49 79 19 80 30 24 58 43 6 95 43 99 22 99 11 99 60 42 33 68 78 26 77 1 13 67 87 31 49 90 6 76 94 76 79 66 51 14 89 87 1 65 53 19 21 98 90 45 77 54 86 2 3 88 39 56 24 91 86 80 58 54 57 42 32 5 43 80 86 47 95 86 40 31 61 12 64 17 52 56 35 60 75 10 50 66 53 58 12 66 81 51 75 71 46 88 58 73 27 26 38 48 8 14 58 89 44 16 20 69 67 80 81 82 27 5 44 38 53 16 48 16 31 79 75 14 67 70\n 28 82 88 33 69 28 92 66 92 30 67 53 93 45 7 70 58 58 17 41 56 34 62 81 44 95 50 88 19 50 25 88 1 6 45 29 2 54 71 81 22 57 16 88 5 52 23 21 21 58 96 37 46 78 87 91 9 96 93 98 31 78 20 75 18 34 48 49 69 88 30 34 22 81 50 40 73 91 7 1 71 72 8 68 49 7 47 90 59 39 49 28 22 10 96 2 88 90 69 44 74 16 90 7 14 47 48 36 62 1 63 86 49 48 3 51 80 86 97 4 58 79 28 19 93 88 44 74 18 95 2 22 7 82 52 17 59 42 51 79 93 65 27 25 60 72 29 55 58 22 58 61 89 67 14 10 40 11 99 7 20 78 6 71 48 39 58 7 17 63 73 43 14 66 59 75 96 28 12 99 63 19 26 8 72 55 67 1 23 35 6 89 93 88 86 37 53 45 32 69\n 15 67 57 64 23 9 1 2 43 73 94 96 78 14 32 23 83 29 75 55 91 44 46 59 11 20 68 3 17 55 59 18 31 84 61 55 46 77 59 98 23 18 17 70 73 38 13 77 74 79 51 48 16 93 29 28 6 82 40 9 88 51 48 1 4 77 48 6 1 32 79 40 14 20 86 40 25 94 73 44 98 94 61 65 44 75 4 17 1 12 78 51 55 53 96 92 82 20 22 13 40 43 23 30 16 76 30 59 64 72 61 13 81 25 90 67 21 70 96 99 64 68 61 36 57 86 10 57 88 59 73 43 25 37 70 97 29 33 99 34 96 65 90 52 95 3 64 21 16 70 67 13 96 57 7 30 96 98 72 31 11 36 10 20 26 67 13 60 50 28 32 49 54 46 15 49 94 63 96 43 73 19 19 81 82 69 13 85 32 34 57 69 63 49 56 37 54 60 97 44\n 52 82 17 66 62 57 58 91 42 69 48 46 18 94 83 48 81 57 93 67 19 65 49 45 22 92 41 38 26 2 90 79 17 61 81 67 18 1 36 31 85 92 6 78 83 39 74 77 85 88 25 33 36 32 82 98 3 46 68 11 30 75 42 93 36 97 1 63 86 54 33 71 1 18 75 55 62 21 71 80 5 48 87 22 5 71 69 75 72 36 54 24 55 5 40 56 8 19 7 12 44 66 39 41 60 11 31 65 16 67 19 69 56 96 78 36 56 12 37 1 50 43 58 13 55 87 20 84 28 59 65 56 2 36 41 7 23 25 81 6 67 5 89 71 86 48 50 54 21 83 27 38 79 71 53 2 9 49 79 39 28 39 70 72 70 38 48 57 11 38 37 56 64 64 68 27 36 94 65 89 23 93 14 57 93 60 82 16 69 57 8 52 98 67 19 56 38 75 69 14\n 5 44 2 98 27 10 25 27 41 59 89 36 62 29 17 37 35 47 37 52 3 87 4 50 96 74 68 30 69 17 34 95 3 24 51 55 60 61 15 38 83 62 84 44 80 48 45 54 71 10 96 23 8 56 35 72 53 13 72 38 1 69 85 2 28 18 10 70 67 95 72 64 19 60 31 29 43 17 78 28 47 78 77 92 42 86 6 19 28 18 4 24 57 82 7 4 94 9 57 82 98 54 2 71 94 69 51 80 79 85 56 79 46 71 85 52 42 66 82 91 48 70 21 82 12 94 17 45 68 60 93 30 5 31 30 71 29 82 20 13 94 47 57 95 8 46 80 32 7 34 33 33 18 29 19 74 58 52 10 70 78 59 32 20 12 98 18 12 57 73 91 46 64 92 45 86 84 15 99 8 87 61 42 25 35 64 74 40 89 4 43 12 28 68 46 23 3 70 81 14\n 53 43 43 56 48 83 34 93 95 48 63 93 91 94 32 81 69 29 44 2 66 25 60 69 44 34 68 77 31 10 57 21 56 36 26 11 6 86 2 89 28 62 63 52 12 13 43 99 11 70 82 14 39 83 4 86 93 87 82 78 32 82 24 88 45 48 67 14 34 76 1 51 15 67 57 3 37 15 50 75 80 3 9 28 44 2 71 89 24 73 28 98 17 27 90 4 13 83 43 63 68 74 12 69 38 74 98 86 72 76 53 94 45 30 39 60 69 12 83 21 25 50 47 43 58 11 63 74 6 23 94 93 26 49 30 50 47 89 43 32 45 47 68 13 86 97 2 16 27 38 53 37 94 78 84 49 25 59 36 33 15 36 47 83 24 71 7 6 55 43 82 40 78 64 96 27 99 11 91 78 97 23 48 20 99 39 53 3 65 81 47 25 36 44 29 85 26 4 9 59\n 55 65 38 76 45 99 84 67 40 93 70 45 75 91 21 72 15 73 43 62 40 43 96 39 23 79 66 19 41 71 60 72 62 17 25 59 95 47 10 94 39 53 50 99 63 59 30 67 18 12 9 41 67 52 39 90 25 13 81 3 8 66 67 51 54 85 10 95 59 64 90 28 48 57 85 78 18 59 11 67 36 24 59 24 39 1 80 58 76 59 90 92 3 51 1 55 50 15 31 99 8 44 91 83 75 66 98 77 8 6 26 47 55 39 91 78 49 23 92 68 88 9 38 60 2 8 86 62 41 66 94 54 9 75 43 9 10 79 10 97 39 30 74 52 90 12 61 34 88 27 68 14 88 74 71 14 16 46 47 54 91 89 59 39 52 91 21 90 58 74 30 63 19 18 88 22 43 60 20 32 67 1 42 95 84 37 30 12 87 13 60 92 52 51 91 76 32 81 57 71\n 81 44 46 3 93 14 86 23 59 47 76 45 64 10 4 29 69 46 68 89 48 68 13 36 85 35 25 21 44 40 20 83 76 26 50 98 6 83 51 46 99 65 46 24 47 24 32 66 48 83 3 74 97 39 80 27 70 65 1 26 46 8 74 47 19 85 62 33 96 33 5 23 43 63 10 47 73 1 19 92 31 29 68 31 92 48 87 8 90 57 40 25 49 26 35 90 99 30 5 52 12 11 72 32 81 21 81 64 45 4 10 90 11 88 52 96 92 44 54 28 85 51 21 4 42 43 55 89 4 1 97 65 38 87 58 47 53 51 40 80 20 24 77 37 13 29 28 18 22 75 24 79 99 35 45 95 46 15 7 24 45 20 35 61 97 69 78 13 53 16 94 59 64 72 13 47 22 9 68 4 67 92 49 23 37 16 39 47 94 71 36 72 67 78 13 68 36 69 28 69\n 47 51 44 27 76 4 76 49 5 25 23 67 55 40 58 26 36 83 65 91 77 62 6 57 87 4 11 60 23 87 50 18 23 24 82 16 96 37 29 19 26 56 33 53 6 95 63 84 13 6 19 16 80 37 20 62 81 52 14 67 19 86 1 53 21 33 68 28 25 69 71 60 69 99 53 77 27 29 83 22 10 42 64 80 73 91 38 60 53 38 19 14 35 10 44 97 17 50 22 19 70 88 31 7 81 58 2 89 1 80 52 15 25 11 97 90 62 69 34 66 54 84 62 71 70 60 54 52 71 9 99 41 30 23 60 1 67 55 64 21 16 94 11 90 48 85 34 7 79 95 50 78 39 79 69 27 42 15 51 44 71 32 66 49 8 7 44 1 15 6 51 91 33 77 69 28 8 8 48 7 55 51 89 61 82 39 89 47 24 79 86 60 67 10 61 60 68 72 9 47\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 1215892992 10494 10422\nprocessing times :\n 3 78 97 19 34 19 17 75 35 84 44 73 93 90 39 93 68 66 77 17 60 6 50 44 23 95 19 59 67 84 27 97 72 58 1 29 17 94 88 44 75 30 89 24 20 69 25 61 44 76 82 13 59 58 61 11 49 5 6 43 17 3 42 38 61 48 19 3 59 72 60 71 18 67 52 72 47 80 70 80 4 63 77 3 82 97 49 23 86 47 46 73 17 53 47 30 5 21 94 99 47 20 71 49 86 34 21 31 42 40 86 21 56 30 40 84 2 93 5 68 68 56 78 48 64 55 54 24 81 17 8 64 39 44 46 23 22 81 12 55 46 57 46 18 54 15 23 5 79 2 86 30 84 80 19 39 94 35 66 75 5 52 64 57 19 49 63 67 92 46 5 83 70 69 82 84 92 8 55 96 9 8 30 17 68 82 16 56 97 59 67 86 97 62 80 94 74 6 92 20\n 87 15 28 65 7 84 61 41 24 18 74 72 12 47 8 61 13 75 6 2 15 13 56 22 2 93 31 84 48 84 19 30 44 75 80 89 61 78 89 78 53 6 54 30 46 95 84 26 77 18 98 87 75 23 61 83 12 73 61 28 72 22 38 72 16 68 91 10 58 11 94 24 75 16 21 89 32 49 73 82 91 86 64 8 36 55 89 37 10 58 48 1 54 43 75 53 13 70 15 57 78 51 59 39 15 87 89 68 44 57 68 6 55 10 32 34 38 27 81 80 88 64 98 87 59 89 39 91 78 10 94 22 12 89 28 92 18 51 92 51 14 55 35 27 35 74 95 11 5 21 70 65 53 59 43 11 15 23 98 85 68 82 43 46 45 26 62 78 43 36 56 65 10 29 56 11 76 81 31 10 69 89 36 29 73 68 69 5 61 75 37 26 35 67 87 62 40 79 49 76\n 18 30 48 53 69 45 28 52 4 52 14 77 6 35 63 19 43 43 4 1 92 3 73 44 2 12 30 10 22 46 24 39 46 4 93 64 82 27 20 25 69 8 87 35 42 4 88 4 43 74 9 15 57 92 16 85 1 8 43 44 26 54 13 10 54 81 75 30 34 16 73 67 57 44 64 7 54 30 81 97 69 13 89 96 68 3 12 24 50 90 53 66 76 20 97 4 84 67 53 3 37 92 11 5 70 68 97 2 3 18 42 13 12 3 34 96 82 3 23 94 20 12 17 81 69 78 4 10 16 55 51 4 18 13 11 93 8 88 53 7 24 66 46 40 95 6 10 51 52 72 13 43 93 53 35 55 46 28 52 17 19 79 91 52 33 4 16 75 94 2 27 62 72 2 23 42 48 61 66 96 27 9 26 19 23 13 25 65 37 52 7 19 30 63 36 56 65 53 87 7\n 32 28 63 90 30 94 81 19 58 57 75 9 46 88 76 29 33 52 53 52 34 23 61 59 41 23 29 52 28 7 27 38 36 7 52 45 76 49 5 98 94 64 70 51 45 74 80 93 83 29 98 9 66 49 35 97 49 42 84 37 67 87 71 84 23 78 34 62 5 33 5 72 49 22 95 35 29 72 87 13 74 97 8 28 46 22 51 71 70 45 91 3 16 16 26 55 17 16 22 8 97 60 58 9 71 29 15 58 55 91 30 46 96 46 99 89 39 27 67 28 66 88 55 50 1 53 90 31 52 3 27 81 12 84 42 19 5 4 7 29 43 93 38 74 6 99 92 94 67 17 90 10 77 93 27 14 4 36 84 57 31 69 12 30 35 17 86 41 93 10 94 91 71 67 50 89 1 56 42 94 36 25 67 40 19 14 79 47 30 80 64 24 74 3 24 83 11 89 78 49\n 43 20 84 51 29 64 41 13 61 25 14 85 13 11 12 34 75 58 37 52 19 92 99 96 75 65 1 51 39 45 16 25 49 84 44 8 65 58 40 21 52 30 59 98 48 62 2 40 46 28 25 87 67 36 87 73 19 87 44 92 39 13 48 68 20 91 95 54 29 82 27 83 75 77 99 57 98 69 62 15 3 16 11 36 99 95 34 2 94 83 4 53 5 69 85 22 30 10 86 7 16 50 92 4 68 26 21 58 48 28 75 55 31 36 93 45 19 58 41 99 45 63 88 59 40 71 99 20 21 71 80 91 30 7 88 78 91 20 15 31 80 46 11 43 17 26 78 24 42 14 51 98 34 4 37 99 53 15 16 77 17 27 52 15 50 21 78 71 1 47 82 56 46 10 79 93 27 16 75 44 1 60 21 73 92 89 51 55 20 33 55 46 73 43 55 66 87 64 92 73\n 85 97 69 92 88 61 65 40 3 39 52 14 40 18 14 55 56 58 47 86 47 42 77 78 42 22 10 56 81 94 27 92 14 85 87 88 45 69 89 27 70 3 86 69 63 16 19 71 48 83 55 32 53 34 9 45 31 61 96 87 78 65 15 23 7 17 67 95 40 86 65 65 65 51 77 13 18 21 80 59 37 62 86 99 12 5 8 11 23 44 85 82 3 58 49 38 65 92 28 49 52 95 41 60 91 83 1 92 3 20 27 35 55 67 10 7 8 69 28 59 34 24 9 17 84 3 19 66 49 19 73 51 46 23 83 65 60 83 51 93 87 88 34 26 88 90 38 73 72 17 92 50 11 76 92 62 88 53 46 25 79 55 46 4 74 65 90 24 64 15 41 6 44 52 15 84 36 37 47 99 10 43 18 23 57 69 55 51 98 9 86 74 40 67 58 64 24 5 74 40\n 15 16 25 55 89 70 85 21 71 7 19 77 67 33 39 83 57 22 71 83 47 64 28 75 6 28 42 30 52 51 32 32 7 45 93 93 31 52 73 40 6 31 53 36 10 2 43 21 9 54 92 32 51 1 11 17 71 62 53 68 28 9 62 25 70 49 86 17 69 7 37 72 35 33 20 90 15 64 8 72 77 48 7 88 69 33 62 62 54 18 31 24 75 22 86 4 44 27 84 86 53 57 10 56 10 95 23 93 96 81 32 80 77 91 47 94 92 68 28 69 79 27 61 78 56 59 28 58 83 98 46 22 51 85 89 11 78 87 96 10 39 38 51 82 5 36 81 5 54 82 74 65 74 72 25 72 43 78 56 30 83 39 50 92 97 30 9 8 79 24 9 13 35 40 36 70 8 77 68 6 80 32 48 99 88 27 28 29 28 91 60 86 81 82 17 20 91 46 14 64\n 77 92 61 36 6 17 31 19 42 17 85 86 54 99 19 78 67 26 25 89 7 38 1 10 88 50 31 80 53 41 14 40 80 42 34 39 19 26 74 39 93 57 66 39 4 92 42 2 72 7 44 85 30 67 69 7 43 63 82 44 15 28 30 83 55 26 1 58 45 62 40 67 6 98 35 96 63 33 64 28 27 15 94 55 19 87 94 39 67 83 21 59 69 24 74 70 38 4 44 32 45 94 91 86 26 27 52 49 59 95 72 75 84 21 31 27 71 87 48 1 71 46 71 5 17 59 73 93 67 8 44 46 28 96 95 34 6 76 64 92 50 8 86 28 90 49 78 59 22 53 59 23 88 79 47 27 66 58 97 95 26 83 22 56 90 3 18 82 72 83 86 72 69 62 75 81 8 95 34 57 26 16 10 98 11 6 10 71 73 47 66 63 92 2 47 12 79 71 29 33\n 91 82 83 81 73 89 5 31 11 15 84 73 45 15 79 51 13 53 28 52 80 59 43 5 94 57 55 71 9 18 6 70 6 64 85 68 42 28 37 30 34 42 90 4 24 59 5 88 68 29 29 99 62 44 52 65 80 81 51 26 2 44 75 19 24 97 57 29 40 27 57 82 43 22 37 3 65 72 21 93 98 54 77 47 90 36 89 68 85 75 21 67 48 10 25 20 40 95 11 9 3 18 8 35 2 88 60 85 3 73 58 7 38 76 51 17 80 81 94 80 16 59 17 54 78 16 23 78 59 49 38 69 83 26 32 8 50 33 30 27 63 23 12 60 6 53 9 98 98 38 59 80 74 83 34 48 35 65 33 63 37 92 97 70 47 55 99 77 49 62 80 52 86 83 45 76 73 55 98 2 36 47 49 67 52 53 59 13 24 25 32 26 62 72 59 12 96 77 4 91\n 82 63 58 32 59 48 41 19 81 9 10 16 20 27 31 87 52 72 92 45 71 52 18 76 15 69 55 56 70 49 97 62 67 35 49 11 56 71 34 78 60 19 93 6 78 77 39 78 45 95 47 92 20 99 13 91 10 34 35 12 43 39 6 6 94 74 1 68 28 58 82 86 17 44 30 51 23 51 3 86 73 60 76 79 99 19 61 42 49 41 98 37 87 79 83 17 30 37 91 30 35 67 72 37 53 45 52 59 13 71 2 34 88 88 25 62 11 14 36 97 26 69 68 65 38 11 8 40 57 10 59 86 90 94 12 75 99 14 13 38 11 18 59 65 60 93 34 3 8 38 48 78 99 50 53 55 46 40 65 84 3 20 67 19 54 59 22 93 62 37 70 66 93 22 39 93 34 26 98 58 73 61 29 90 68 10 3 8 27 30 99 64 47 42 65 39 32 48 82 5\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 135346136 10922 10886\nprocessing times :\n 27 36 70 14 97 81 3 30 73 81 34 93 74 57 73 41 81 76 81 57 48 92 80 36 5 99 61 80 53 56 92 54 57 53 85 21 65 50 76 41 61 66 88 30 62 40 46 35 25 46 45 44 83 59 75 20 88 84 38 71 47 33 33 84 48 59 67 73 8 36 55 41 3 78 79 79 80 67 89 33 90 18 6 82 38 6 24 99 2 67 73 21 50 31 33 29 2 45 16 14 95 79 69 67 92 77 65 93 88 98 35 89 94 30 17 91 83 46 49 92 48 79 40 36 11 15 44 41 28 30 79 59 42 31 36 21 75 93 56 21 19 96 91 48 40 51 8 66 90 63 4 63 61 8 78 82 9 47 41 91 33 61 56 44 16 3 87 92 60 91 82 88 65 28 95 88 35 93 29 60 43 22 10 10 60 8 1 10 67 43 21 69 57 65 50 83 33 14 32 68\n 37 58 7 22 31 18 48 29 49 39 77 2 24 79 9 77 28 39 76 9 10 77 79 79 44 34 56 91 93 89 49 26 53 26 37 43 96 37 7 94 36 80 7 40 49 57 54 78 11 41 70 25 15 48 25 87 18 81 35 81 42 18 20 63 80 37 89 18 72 84 95 80 43 9 80 74 16 32 93 85 96 57 19 2 28 35 60 12 77 42 21 70 64 87 15 38 6 90 32 17 32 53 86 29 60 23 96 34 33 41 64 56 34 43 83 54 24 65 22 98 77 55 54 17 46 75 80 67 63 87 7 87 5 63 2 87 90 83 5 64 16 32 14 68 41 8 59 52 68 20 51 99 6 72 69 80 25 7 19 87 83 72 78 74 63 21 81 93 85 5 46 71 98 49 99 21 78 97 68 48 68 16 37 80 56 10 80 54 73 84 80 40 93 27 96 11 56 6 57 55\n 15 30 65 42 12 72 87 2 12 32 94 38 36 49 3 72 83 69 33 89 62 12 17 39 93 25 7 58 10 53 41 55 87 22 92 86 72 77 42 99 96 42 18 6 95 64 11 61 47 13 31 23 72 51 58 46 19 8 46 3 62 48 93 68 52 1 90 16 58 36 60 63 26 89 56 17 36 86 65 66 84 58 27 13 43 16 39 48 29 75 25 7 79 41 32 70 67 87 31 15 86 44 17 31 55 90 3 19 78 81 23 39 82 28 11 43 33 59 8 37 48 79 13 29 6 21 87 13 42 63 72 8 6 22 49 51 69 95 92 44 31 42 63 55 99 40 67 4 51 63 18 73 45 4 30 71 12 85 20 41 22 37 53 32 90 25 19 9 22 51 45 43 44 25 4 33 11 73 99 1 75 98 50 24 61 91 13 57 45 99 83 59 56 83 52 24 64 99 27 95\n 76 35 82 4 75 68 80 32 76 11 83 66 2 6 14 53 78 18 95 2 84 17 49 19 20 22 79 9 56 64 29 8 59 65 57 34 1 49 12 43 60 31 48 3 83 20 93 44 99 96 1 9 4 79 56 38 1 40 88 54 71 15 59 9 57 58 23 21 5 41 9 31 81 25 87 91 29 30 50 63 55 17 3 24 81 76 28 2 58 77 24 16 49 77 7 4 17 5 11 82 31 9 55 36 95 52 79 73 51 57 40 62 72 86 46 98 70 59 8 52 28 15 40 44 8 31 81 54 59 76 62 73 16 37 39 89 90 39 90 12 58 69 20 81 46 86 60 51 99 7 4 10 79 89 80 63 29 80 54 99 45 59 69 10 67 45 49 92 64 76 53 4 43 29 73 98 76 31 66 11 10 51 27 84 79 78 40 51 10 39 54 31 67 65 63 91 44 42 40 77\n 32 4 15 2 87 35 7 67 98 75 90 65 25 30 75 4 57 38 55 28 15 88 38 71 21 87 7 28 21 79 1 76 35 57 75 65 9 53 11 75 34 23 44 95 81 31 50 77 43 13 39 12 72 35 65 79 99 51 52 5 80 52 73 15 97 35 53 72 93 36 88 93 64 27 60 92 86 6 26 98 10 46 47 61 39 45 99 50 36 70 4 72 56 67 42 83 12 53 70 53 84 19 43 64 8 75 75 94 39 57 89 16 9 90 34 69 58 35 60 18 72 64 96 92 12 96 85 30 36 21 1 41 59 32 75 45 38 91 93 43 91 73 79 56 76 9 10 36 43 60 67 87 1 7 85 32 52 73 99 38 97 32 72 89 54 10 74 61 61 45 80 99 47 89 8 23 5 27 46 44 41 73 84 20 47 49 10 78 75 66 17 20 86 93 93 88 90 79 78 87\n 60 3 84 97 75 73 80 31 45 12 22 70 81 88 22 91 33 5 21 57 16 28 84 38 97 98 82 13 3 97 64 25 22 21 58 49 12 77 51 73 27 34 77 29 9 16 92 49 57 57 74 17 51 38 81 94 32 35 32 90 13 77 79 19 75 82 16 13 25 64 88 14 23 15 79 66 48 87 77 72 77 76 50 38 67 53 41 8 57 41 36 5 35 27 5 67 1 3 55 21 7 63 56 12 63 61 56 35 92 88 91 86 65 87 81 82 82 84 7 84 16 43 14 85 83 32 28 39 1 82 89 62 21 24 60 92 64 80 35 42 42 76 93 95 34 85 12 76 69 71 94 86 34 30 41 51 16 95 23 15 35 44 61 94 94 72 5 56 88 76 50 86 45 97 91 46 86 3 69 14 14 14 64 26 19 78 58 59 19 59 39 62 52 15 90 56 79 2 39 49\n 5 16 23 42 81 88 60 7 16 74 77 89 77 13 58 4 54 24 66 65 85 5 25 48 29 43 94 89 56 27 93 1 42 40 7 50 84 14 24 72 42 64 57 2 84 99 58 89 70 10 15 57 53 95 94 54 9 21 83 23 28 85 46 67 48 2 76 55 47 93 88 45 18 99 20 16 46 31 74 78 84 72 39 29 15 59 89 71 11 40 62 18 11 46 17 87 12 48 96 59 55 66 36 66 57 60 71 35 61 18 69 81 87 78 72 35 90 19 79 47 78 99 59 44 50 61 86 62 9 85 91 66 33 63 84 19 75 5 70 72 32 46 57 41 81 45 68 81 60 43 96 50 88 32 42 49 73 82 6 97 50 83 21 79 97 9 68 5 43 23 29 69 6 9 21 72 96 25 31 76 82 47 50 11 33 6 54 73 16 11 39 21 63 67 30 36 51 13 27 12\n 70 21 47 18 17 44 57 39 48 86 53 73 93 59 41 81 39 11 49 37 70 79 84 1 1 78 13 8 39 17 83 38 10 73 41 16 43 32 28 87 41 42 45 48 92 27 76 27 8 36 33 16 61 24 36 66 10 47 6 74 79 39 84 64 67 41 6 24 17 53 47 21 91 98 80 62 56 14 39 77 16 69 5 6 66 82 84 6 19 67 65 65 46 8 28 40 35 22 86 75 18 51 10 58 85 21 96 14 99 66 7 40 55 37 35 37 85 66 66 7 64 83 60 91 23 12 92 36 98 66 15 12 57 63 15 41 49 42 7 48 69 75 55 50 94 59 67 20 29 74 51 84 31 98 16 53 66 61 15 31 51 71 51 58 39 84 90 91 22 63 91 22 6 44 19 33 68 4 8 49 67 75 22 21 9 41 37 82 52 4 28 61 70 98 36 54 91 14 87 96\n 11 34 11 85 82 56 59 76 46 27 91 46 22 61 51 54 82 67 24 33 49 95 7 44 7 8 75 46 38 93 68 12 32 86 78 27 77 72 11 43 80 23 26 75 64 76 60 31 11 21 10 26 97 51 47 79 99 47 70 45 32 1 5 89 92 63 93 96 13 59 34 68 78 85 41 81 36 21 31 46 41 34 9 24 41 88 41 55 27 66 37 4 39 46 8 25 52 41 83 56 74 36 22 4 34 84 54 43 89 29 99 48 26 16 14 45 68 87 40 55 8 51 90 86 75 10 41 40 34 82 34 44 20 34 1 21 44 2 74 36 56 16 93 85 33 41 46 78 37 21 92 9 88 8 23 82 63 91 69 2 45 77 15 2 98 13 69 83 98 2 41 33 63 10 34 20 4 55 38 42 46 90 14 80 96 55 5 56 80 65 37 72 93 27 18 67 6 64 79 4\n 67 81 59 68 16 95 57 84 44 80 73 54 58 41 24 95 74 38 25 15 40 19 70 20 61 25 31 63 98 72 91 50 34 97 44 1 44 73 78 32 39 77 21 20 31 92 67 80 26 68 56 11 34 90 84 80 50 82 40 23 19 34 78 11 48 98 86 95 69 65 49 24 70 74 48 34 88 52 97 16 6 15 64 47 49 40 90 93 51 18 16 59 56 61 72 22 35 9 33 40 3 13 84 97 89 52 98 42 63 14 74 97 3 94 76 8 46 3 14 78 26 85 46 63 72 32 77 54 45 77 74 84 65 17 3 71 74 84 38 71 49 7 35 88 35 62 13 40 73 24 71 70 22 11 97 71 36 38 51 21 90 87 87 82 14 99 99 22 46 78 82 52 4 98 44 18 61 80 98 52 67 58 92 76 99 10 78 36 19 44 50 54 24 27 16 61 72 34 25 51\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 1602504050 10889 10794\nprocessing times :\n 79 23 2 94 66 87 2 19 50 25 36 87 55 14 68 11 14 58 17 34 88 98 53 7 2 15 89 46 15 42 66 50 28 45 18 72 23 20 2 46 68 98 2 65 69 80 87 60 22 3 85 24 95 95 36 2 67 71 18 18 32 15 72 30 41 29 71 51 1 71 27 98 15 73 87 49 97 74 29 50 32 13 55 40 4 82 89 43 88 10 13 93 58 60 2 30 73 84 51 80 92 9 53 77 84 57 27 26 95 61 5 67 88 37 2 32 94 18 82 39 99 88 68 33 86 34 75 30 51 35 40 10 82 1 26 3 51 31 74 87 52 79 51 36 46 5 12 65 58 78 50 51 12 99 38 72 73 39 10 35 44 96 68 51 9 89 72 16 42 24 99 62 30 49 91 31 98 90 70 79 47 4 95 78 49 35 39 27 53 55 11 6 40 51 45 45 29 29 96 46\n 63 55 35 95 20 22 7 96 58 10 4 73 76 25 45 80 89 97 99 46 80 37 3 41 20 7 12 61 37 1 97 66 88 56 63 64 25 67 99 20 55 7 19 22 47 85 52 62 81 14 98 96 91 25 65 61 34 33 27 95 15 31 27 45 86 39 50 22 26 50 69 9 98 39 61 4 57 79 80 24 81 28 38 14 92 86 85 87 70 2 8 26 56 56 91 74 88 56 58 74 93 18 35 76 43 58 34 26 79 36 29 69 99 97 52 62 76 51 41 9 56 65 84 21 66 95 10 90 51 86 30 41 70 72 81 72 8 28 68 39 76 15 96 61 85 22 29 67 69 96 14 93 20 27 84 78 73 38 49 6 58 5 34 84 45 98 74 25 83 62 29 99 48 97 18 61 81 74 48 46 47 96 1 27 45 52 9 39 5 2 1 32 80 23 16 17 29 31 65 27\n 83 95 73 87 65 59 14 91 79 95 39 74 52 13 10 93 56 98 71 20 49 68 8 28 56 9 69 22 28 55 99 28 86 47 18 4 29 40 60 21 81 52 2 31 53 66 46 8 63 70 36 92 40 96 45 35 45 94 13 95 84 82 81 77 25 84 63 20 58 97 53 96 30 63 26 18 19 3 84 46 70 50 49 90 64 23 38 63 87 19 8 48 22 74 82 67 16 74 57 2 37 18 12 45 49 9 77 85 57 97 52 19 27 90 33 78 58 86 11 33 47 68 35 60 4 52 52 38 81 21 21 89 46 48 65 31 43 28 86 77 88 26 99 36 30 98 66 9 95 73 73 95 8 72 52 34 65 21 56 11 60 91 94 94 76 32 71 17 53 50 90 36 6 42 74 17 45 26 57 33 51 48 45 21 79 54 22 32 9 22 26 68 80 35 86 7 92 30 17 71\n 65 94 77 47 42 67 6 70 42 26 49 64 60 14 3 36 17 61 11 98 14 76 94 49 7 99 20 73 87 92 78 14 62 99 94 22 45 44 36 88 76 61 62 7 50 67 50 45 63 31 83 52 89 53 9 27 56 10 74 76 13 26 80 76 15 89 86 94 74 72 44 4 63 19 12 76 60 13 50 45 99 85 15 84 18 65 30 73 25 19 88 2 83 26 49 58 72 26 43 68 49 50 96 79 47 54 9 81 26 76 59 69 5 74 49 41 11 62 28 4 18 59 40 72 1 11 96 3 83 31 7 59 53 77 94 28 43 20 71 80 76 23 54 73 50 58 45 88 19 44 49 30 1 40 79 78 28 91 61 18 18 90 20 47 46 45 59 14 49 14 68 88 24 43 87 82 96 21 46 93 29 12 94 96 40 84 35 45 38 84 17 43 91 25 18 8 41 78 37 66\n 35 52 46 86 25 73 17 40 66 21 24 94 86 35 58 66 30 97 44 81 43 63 43 50 86 50 96 35 67 36 96 60 65 53 86 45 88 95 86 98 46 78 74 26 43 63 29 67 83 62 68 80 55 41 17 5 71 48 44 22 69 21 47 37 90 63 25 53 32 60 15 40 42 27 24 9 44 57 25 92 10 47 76 87 91 25 17 77 24 51 89 69 90 78 21 13 40 55 40 91 83 76 23 40 55 15 10 6 70 21 57 40 43 37 75 44 95 33 41 82 21 27 64 95 41 21 45 37 52 7 97 65 24 55 52 17 51 81 76 44 22 48 24 18 29 93 18 79 74 22 29 87 67 50 30 56 17 22 6 1 24 39 21 93 13 83 44 48 70 34 77 82 69 14 85 48 67 12 15 24 88 81 95 26 25 31 47 30 53 19 68 6 68 34 15 3 17 62 28 14\n 53 52 9 62 68 92 93 6 80 28 1 28 41 90 19 51 8 38 19 54 27 79 67 75 57 74 11 80 75 17 78 58 13 77 7 38 97 22 57 93 42 4 16 95 76 86 2 91 76 10 34 48 47 62 80 60 16 63 8 29 39 70 95 44 84 86 7 98 40 37 32 80 26 58 16 55 47 54 30 38 43 38 96 45 95 35 23 24 77 36 85 14 92 69 95 64 87 67 36 53 65 57 10 17 46 97 77 27 67 34 19 33 21 70 22 43 25 66 18 50 68 30 31 5 88 32 56 36 93 71 45 39 22 19 2 31 99 74 52 22 43 77 43 22 52 75 13 98 15 15 11 60 86 52 69 14 85 5 40 4 13 38 13 17 37 89 67 86 92 89 69 67 19 41 84 10 6 22 19 63 60 67 22 88 27 32 19 42 57 40 97 22 88 98 62 29 79 40 44 62\n 51 17 35 11 25 90 89 3 13 76 44 66 12 94 47 22 40 48 52 85 90 16 77 4 24 29 29 56 17 95 74 56 61 97 48 55 33 1 29 39 5 51 94 36 94 19 22 53 98 63 4 61 66 28 37 55 96 28 77 87 34 32 92 27 80 69 54 19 7 82 24 91 52 35 60 62 87 68 42 80 14 49 20 74 31 21 71 33 46 8 33 58 20 28 93 40 40 44 18 7 56 94 37 68 11 17 90 31 85 64 44 54 61 78 91 40 45 33 70 58 83 14 48 65 8 30 77 90 60 50 19 13 49 12 98 16 37 97 14 47 35 55 23 35 6 16 25 78 84 71 70 87 53 97 27 63 84 16 71 7 44 35 89 2 76 8 68 99 68 47 6 60 17 51 69 53 29 65 42 32 45 16 27 42 51 78 19 57 16 99 74 15 15 65 15 43 52 74 35 92\n 68 6 38 6 24 58 99 85 54 19 30 29 5 56 81 65 20 4 90 8 9 52 41 93 70 93 56 21 16 9 29 9 19 13 11 41 88 71 66 56 13 49 29 89 27 68 77 72 78 20 80 92 22 95 86 29 28 11 59 16 58 38 5 2 70 13 14 56 53 17 14 94 96 60 95 11 77 75 41 9 8 17 51 62 72 55 53 31 66 57 24 11 47 75 25 62 13 41 20 98 65 51 28 70 56 86 30 63 77 65 24 65 64 83 10 23 34 9 58 33 92 46 86 43 23 75 52 15 34 8 3 36 16 62 12 62 37 99 85 55 83 11 40 15 45 27 53 50 42 86 12 77 35 92 11 16 38 18 83 29 75 42 92 99 64 71 57 9 70 68 93 75 82 49 74 78 6 67 95 18 48 72 29 32 48 58 88 83 91 32 96 59 67 7 89 27 56 63 20 28\n 34 50 86 40 65 40 83 24 9 19 90 9 21 89 92 94 23 6 55 54 78 92 20 11 33 77 49 98 96 73 50 5 17 76 84 53 10 39 58 92 92 24 65 38 13 97 79 88 84 38 55 5 52 60 40 44 63 47 68 90 30 78 8 7 8 40 63 89 62 68 51 9 97 22 42 62 26 44 72 38 44 62 85 97 77 69 25 49 60 22 4 7 54 62 95 26 24 46 24 20 8 59 66 53 30 24 25 84 70 95 48 76 62 99 78 73 25 62 39 51 31 91 11 41 78 71 49 48 90 38 6 27 19 20 43 38 3 73 32 74 78 67 21 52 6 6 1 90 22 13 88 26 10 79 9 98 29 37 57 36 12 65 17 59 65 12 50 59 90 16 70 69 8 23 78 45 72 26 88 43 37 91 63 10 23 75 23 23 4 71 76 98 2 62 44 8 10 61 33 43\n 87 70 78 31 98 10 75 57 73 74 49 50 6 95 40 48 37 33 63 35 43 13 31 75 39 24 78 84 68 25 46 68 45 11 80 27 93 17 16 43 31 98 99 72 83 45 32 82 94 40 24 79 56 3 24 10 50 64 68 84 49 66 77 55 74 33 40 64 94 17 69 89 91 65 59 1 95 86 98 15 33 86 87 13 93 10 16 43 86 38 42 99 77 31 51 12 56 11 24 95 58 61 51 10 1 43 81 33 76 61 50 40 94 27 2 31 94 60 77 31 50 75 94 39 57 27 89 10 68 86 46 81 52 25 75 43 51 58 9 56 89 39 95 35 60 77 39 32 28 21 69 95 78 40 86 58 71 21 39 45 50 60 7 69 29 58 62 99 10 65 34 91 67 94 3 50 88 20 42 39 75 46 78 72 84 84 25 24 55 39 41 13 37 40 87 53 96 8 3 48\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 160037322 10524 10437\nprocessing times :\n 51 36 26 84 92 80 39 29 63 95 46 19 66 98 90 41 9 11 96 69 33 71 64 90 13 45 83 53 3 94 87 11 26 66 58 54 20 50 19 49 68 54 26 35 93 6 76 61 76 65 58 31 60 52 18 45 9 18 73 79 24 96 23 53 38 79 20 51 45 50 56 64 30 21 23 4 86 63 19 6 83 98 42 72 80 68 66 58 41 48 85 52 28 76 74 34 96 18 2 85 35 57 78 18 47 4 71 33 32 32 57 92 89 13 24 60 45 69 24 70 80 82 11 38 60 74 11 71 81 6 21 89 34 41 97 62 53 75 68 9 64 1 66 26 45 97 43 6 90 23 14 51 69 24 86 61 57 74 76 63 28 87 14 26 4 10 82 65 91 39 26 55 89 89 65 79 77 48 84 44 10 82 36 1 55 96 56 43 24 76 2 31 5 30 74 60 99 7 97 26\n 25 56 21 11 3 36 42 32 84 68 59 22 62 50 72 76 80 20 95 18 21 45 60 83 65 83 55 59 31 90 52 2 35 86 68 93 23 75 79 34 51 46 25 54 8 49 68 56 25 92 1 79 62 1 45 84 22 35 61 64 9 36 29 15 74 68 78 92 94 73 43 17 82 36 81 66 66 83 87 30 91 63 24 98 9 79 85 4 14 50 60 59 87 98 28 77 11 26 14 44 9 32 57 93 50 46 84 28 66 62 17 25 41 6 94 87 36 94 40 64 76 43 27 13 37 35 93 31 84 84 74 71 80 73 19 63 51 27 73 91 59 92 69 31 71 75 26 98 68 1 74 58 6 30 63 30 50 36 72 37 98 99 30 2 2 95 90 45 84 86 88 18 94 24 26 94 63 15 81 21 22 50 80 10 33 51 37 21 41 38 12 10 49 12 50 28 58 4 33 80\n 97 99 2 68 20 65 74 26 19 27 34 44 32 1 6 62 57 85 23 6 69 39 58 82 12 28 71 23 52 12 93 97 48 66 6 44 93 39 69 27 72 81 86 60 52 13 31 34 91 56 7 85 71 54 60 92 83 67 16 4 28 92 81 76 63 77 47 74 95 23 70 6 12 4 74 90 68 86 19 35 25 72 77 2 44 60 52 82 62 98 33 7 42 98 52 35 96 83 13 37 64 28 30 56 38 57 91 24 38 73 32 7 70 62 5 90 57 41 63 57 25 93 76 5 61 46 82 58 71 8 18 17 91 94 17 3 41 6 44 58 48 82 25 91 58 87 13 8 19 89 89 1 88 39 54 87 39 93 48 93 1 25 66 98 54 92 83 81 90 36 84 55 82 19 38 39 5 1 50 44 38 56 5 74 31 29 21 12 14 75 95 1 32 93 56 27 71 29 28 46\n 83 11 73 4 73 98 9 36 86 50 20 38 92 16 76 63 18 93 32 65 2 40 81 92 65 51 49 39 10 83 68 36 80 33 38 41 83 61 77 61 97 2 59 82 5 35 62 81 71 27 4 10 75 58 74 86 39 38 84 15 88 77 5 6 42 22 1 61 64 16 37 18 1 2 50 4 16 99 51 74 56 2 62 56 59 75 54 92 18 21 23 96 55 32 9 24 70 16 13 49 63 97 40 84 12 21 16 48 53 31 22 72 28 69 39 10 53 59 77 13 12 73 22 29 13 96 4 45 32 40 75 39 86 63 52 62 56 70 78 85 89 98 9 5 90 9 69 73 24 67 13 49 25 12 94 14 2 98 73 51 7 58 20 39 33 65 33 43 1 73 24 6 32 28 99 42 71 62 75 15 75 7 82 66 9 13 40 40 90 48 97 11 29 10 42 88 73 21 40 26\n 42 9 69 37 72 46 50 54 87 39 6 65 91 92 95 48 21 19 80 53 81 84 40 28 71 33 41 76 70 48 75 11 10 73 32 21 17 46 75 54 51 57 15 30 20 98 89 36 89 8 26 47 75 3 1 47 97 67 13 14 66 4 60 73 33 70 27 8 83 99 27 47 53 75 79 6 99 36 34 66 77 38 43 52 97 8 42 95 57 84 93 19 71 51 44 18 16 63 77 81 26 39 47 65 16 47 3 62 56 41 11 42 34 56 95 99 78 78 69 47 52 24 66 73 65 6 17 96 62 25 68 34 38 99 41 46 75 26 65 59 41 45 61 47 99 32 87 44 8 50 38 74 59 57 7 77 52 86 83 54 73 75 97 5 94 29 92 47 86 58 23 34 64 9 31 93 90 9 2 96 39 26 99 83 54 34 81 8 81 43 27 51 13 87 34 42 16 19 99 6\n 44 39 29 17 3 21 40 94 88 52 15 71 55 2 53 85 54 3 70 38 67 42 38 34 15 17 56 86 43 16 59 54 61 8 49 82 30 15 60 14 96 84 89 91 68 45 75 87 62 51 52 65 62 92 21 53 46 50 90 79 17 91 35 34 66 30 63 35 77 56 69 80 82 47 96 77 80 13 18 19 26 67 89 42 93 23 66 34 48 13 22 65 52 18 64 48 83 50 93 26 27 66 10 52 3 81 67 12 77 96 85 66 45 37 95 40 33 26 83 46 68 83 94 9 1 26 71 9 93 76 3 10 99 88 11 84 43 65 38 16 20 71 75 12 23 17 61 79 32 11 65 48 63 51 17 91 14 99 69 60 67 76 33 2 9 72 94 76 54 84 62 31 30 33 11 21 41 61 85 49 29 81 73 82 11 15 55 13 33 40 48 84 89 3 26 82 74 84 43 97\n 45 50 79 28 88 81 35 53 21 65 86 84 27 44 11 57 41 11 89 83 43 24 76 6 71 33 53 46 36 21 21 35 15 62 22 55 32 38 35 10 42 59 78 29 97 7 28 35 69 83 75 16 75 92 51 61 41 33 92 66 62 27 32 77 52 82 41 53 70 53 72 49 7 65 34 96 59 78 14 74 85 43 98 93 78 8 51 87 13 17 14 21 52 16 21 1 74 71 86 37 32 3 47 99 51 36 34 72 79 33 36 70 67 65 63 72 36 36 60 42 78 30 11 67 77 34 11 60 76 67 9 33 77 37 75 84 84 16 37 20 21 80 83 20 99 52 52 95 49 80 63 96 82 36 11 33 70 1 7 42 52 91 54 70 49 52 1 29 53 58 42 56 35 15 13 94 77 69 39 69 35 42 14 1 44 9 45 51 10 55 64 79 4 50 54 16 86 35 95 94\n 69 56 80 92 85 50 40 87 99 86 41 42 65 61 63 48 97 96 40 86 66 13 82 85 78 14 86 61 32 32 7 50 61 93 77 70 53 82 99 24 35 77 86 96 97 39 53 21 27 34 68 89 98 7 19 23 40 27 11 84 7 62 27 9 61 29 93 26 37 12 78 68 8 9 86 39 90 47 88 67 58 63 23 6 15 13 86 90 18 15 30 10 8 65 77 84 20 18 76 98 5 68 4 25 46 44 57 20 9 10 64 77 49 63 83 12 52 56 57 79 32 31 45 23 2 48 27 19 95 75 24 49 31 85 21 39 56 85 70 76 62 61 18 22 25 3 58 11 19 41 73 47 12 64 69 61 5 30 17 4 33 38 59 65 68 16 67 6 12 27 93 22 95 10 60 14 75 73 25 6 60 5 97 14 89 11 77 77 67 45 12 40 65 26 28 51 20 46 85 49\n 78 50 21 31 43 10 88 24 86 46 17 4 36 16 98 30 31 72 71 71 95 12 75 70 56 93 12 92 94 3 9 6 55 65 2 91 97 4 83 87 84 32 3 17 55 42 67 16 85 4 55 16 91 62 63 89 30 8 23 8 83 37 65 18 1 29 47 48 8 31 13 59 89 9 36 69 41 63 31 5 35 46 93 36 56 16 43 94 33 13 35 16 45 25 42 31 42 47 75 9 44 74 56 37 47 50 70 74 50 4 36 81 72 55 38 64 6 21 92 52 96 46 28 13 52 46 73 31 31 99 33 23 69 80 71 40 97 90 11 24 91 93 97 92 60 30 40 36 16 27 4 74 15 36 51 87 94 51 7 25 75 88 45 93 12 44 89 19 93 71 8 15 1 35 60 45 78 44 33 78 6 80 40 12 38 42 98 38 12 96 14 32 37 39 33 43 71 33 99 24\n 34 17 39 92 77 33 85 83 86 51 69 14 24 42 16 11 75 73 62 89 79 40 32 65 77 62 84 6 13 20 73 39 1 98 19 24 44 88 17 90 13 29 70 70 92 71 93 90 11 88 8 17 36 78 50 21 17 22 92 13 64 90 3 13 28 91 22 72 10 15 82 14 25 66 54 83 5 61 77 85 13 33 29 7 20 50 22 26 37 14 54 65 35 28 78 73 20 61 57 97 29 88 84 71 9 55 28 12 17 98 93 80 99 90 33 81 31 62 39 9 79 47 36 18 31 72 65 35 73 41 47 66 33 12 57 28 73 87 39 67 81 93 17 25 63 32 24 89 27 93 69 76 86 88 67 39 71 76 67 95 6 90 87 49 25 37 1 68 32 67 45 65 48 12 86 37 6 94 58 38 49 51 9 46 98 40 72 26 15 98 37 46 74 61 16 98 26 61 31 4\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 551454346 10331 10255\nprocessing times :\n 88 93 78 54 48 89 7 46 22 64 33 76 49 60 98 69 66 25 93 38 1 94 40 69 22 43 69 69 27 68 23 50 97 37 27 51 71 83 30 73 10 50 69 29 55 5 38 99 37 29 45 4 82 83 21 31 27 43 7 64 39 96 16 92 62 75 18 21 62 4 50 1 96 83 53 65 4 48 42 62 92 22 82 87 21 79 5 19 2 95 18 4 5 79 7 95 82 33 23 7 45 43 49 35 43 84 41 50 62 5 8 43 34 25 31 82 66 48 82 40 59 45 98 56 37 36 85 94 10 45 50 23 95 71 12 21 24 85 26 29 61 55 15 81 23 70 31 52 62 31 70 30 72 73 13 12 69 12 20 73 73 38 84 39 10 69 98 39 66 67 82 29 82 42 83 21 92 34 49 59 63 3 20 11 15 90 61 80 90 81 19 24 36 88 70 76 16 97 59 12\n 84 24 99 98 24 57 71 38 14 41 45 28 11 81 7 68 24 88 28 7 29 31 38 56 26 17 25 24 53 40 97 89 87 12 97 22 24 7 13 61 36 58 74 53 31 31 4 83 48 78 76 34 28 26 12 60 51 69 88 82 86 68 51 6 79 23 67 71 6 38 17 36 14 49 80 54 63 64 47 31 88 45 82 86 7 84 62 58 89 97 80 54 54 93 23 77 97 55 2 31 52 1 76 89 69 98 68 51 54 33 73 46 94 66 60 37 40 82 29 37 80 27 71 98 47 41 7 79 68 45 59 80 63 10 78 8 31 35 1 64 1 18 5 66 86 18 34 55 18 74 98 90 1 80 34 89 22 2 88 66 91 14 86 6 95 61 59 48 36 5 75 21 55 44 67 87 82 62 7 71 4 92 38 79 15 56 22 38 85 42 72 75 90 62 19 49 18 21 41 21\n 41 8 16 10 99 83 84 96 8 7 47 62 17 26 84 36 49 42 78 41 61 35 45 65 38 37 49 35 28 99 94 44 9 18 33 32 3 96 50 66 50 76 46 42 91 72 1 46 5 89 39 46 21 9 20 40 88 94 93 33 95 49 57 30 66 45 30 63 68 36 90 81 10 53 82 54 94 25 61 13 27 85 58 14 27 68 49 96 29 28 20 67 12 9 12 53 92 50 48 12 39 29 21 35 70 7 33 15 43 84 43 11 70 71 4 48 58 78 71 37 79 25 28 83 26 6 39 30 15 9 23 30 53 63 2 37 39 45 54 52 40 18 64 98 14 31 12 83 58 28 25 78 25 90 99 26 70 31 47 63 53 4 64 19 10 69 74 57 37 55 21 83 22 72 66 37 81 27 57 22 25 87 21 13 74 26 41 84 9 8 19 64 9 75 30 3 90 4 71 91\n 11 99 9 98 77 31 62 3 14 90 5 79 42 8 36 78 80 28 59 91 35 11 32 98 49 24 93 38 2 54 63 73 49 25 93 10 59 43 2 77 71 23 73 86 82 48 41 1 75 95 69 35 91 83 11 82 18 90 41 3 12 9 61 58 20 73 50 74 17 35 11 90 96 93 32 10 73 19 59 11 42 8 57 98 6 17 91 98 14 17 4 19 46 40 86 77 5 48 82 3 61 6 34 13 78 76 33 98 87 45 66 21 34 77 59 54 90 41 92 48 57 78 28 59 96 42 63 38 72 52 9 8 16 56 75 56 88 32 62 82 82 85 38 37 29 26 37 57 90 65 36 1 89 43 67 50 71 87 23 69 83 84 32 27 10 83 39 59 17 17 42 63 7 50 33 7 52 16 85 62 72 5 53 33 81 38 48 70 62 22 94 94 33 85 41 93 12 2 40 90\n 16 26 28 66 62 24 12 41 26 74 84 24 27 51 98 87 12 1 73 99 81 44 10 75 41 32 71 46 18 84 43 93 63 17 52 23 83 68 99 33 65 82 10 90 82 82 41 62 45 81 67 17 50 71 78 93 4 67 21 58 49 10 51 66 4 40 32 2 2 94 2 47 9 13 19 22 89 41 39 96 87 81 60 33 30 86 85 91 25 31 56 22 75 28 44 6 65 2 14 5 91 54 37 26 4 22 66 24 52 46 60 69 87 27 36 39 71 18 21 68 56 72 98 96 23 9 32 4 56 14 14 22 79 10 41 96 38 6 55 89 50 96 44 8 7 82 4 25 7 37 8 8 17 53 20 37 69 77 31 79 19 72 80 37 96 19 1 96 89 46 76 5 66 25 15 41 23 29 66 16 4 27 3 56 75 48 49 73 2 26 82 19 62 93 34 71 45 37 73 36\n 75 12 94 99 63 12 55 99 30 24 58 34 40 22 74 18 37 46 78 32 55 32 8 52 45 60 83 89 92 31 53 96 47 73 94 5 83 40 78 2 14 54 62 11 2 26 66 48 39 39 4 19 15 46 85 95 75 36 81 6 7 92 30 59 57 33 76 67 13 25 89 63 83 25 50 30 59 23 19 92 65 94 8 9 67 85 89 22 39 21 39 56 41 80 27 32 47 51 58 1 45 2 68 84 91 46 34 92 3 91 66 62 85 9 64 45 63 64 25 62 76 78 6 92 77 87 65 6 95 53 25 71 39 3 17 77 38 22 84 65 78 26 5 88 83 15 1 27 62 94 39 46 62 14 26 45 1 26 76 33 39 92 36 68 90 75 4 2 32 29 39 51 40 20 22 21 63 46 92 72 54 51 89 13 90 62 13 86 76 2 8 80 70 82 13 42 91 87 31 12\n 54 62 18 82 86 48 99 54 33 55 47 2 9 39 20 57 84 27 99 50 95 79 2 16 17 76 47 12 8 15 27 96 76 48 42 56 15 42 16 12 67 16 60 83 75 65 52 36 87 6 35 15 21 77 26 51 2 42 45 2 94 1 30 97 55 98 5 2 67 94 25 11 3 83 76 27 13 49 28 28 58 24 12 32 19 45 42 50 31 27 75 81 42 54 52 70 1 87 54 63 59 19 71 74 95 31 2 76 26 98 22 30 57 91 6 63 91 19 28 39 54 51 79 27 31 21 76 90 87 75 39 97 33 8 42 38 84 23 78 83 3 57 32 69 67 9 38 78 80 6 91 94 43 98 78 48 79 75 15 13 33 25 5 89 67 33 11 7 65 89 91 63 28 95 16 21 25 4 2 64 44 53 4 90 53 93 50 68 92 93 47 37 38 92 20 79 9 47 71 39\n 32 46 16 31 49 45 80 53 59 7 57 80 36 68 95 28 68 26 57 28 25 96 78 90 75 45 30 39 52 66 83 33 93 93 40 10 2 53 11 29 46 79 3 2 65 74 52 24 99 66 15 68 92 10 38 21 79 78 93 81 1 26 97 9 98 9 27 28 11 49 92 55 54 79 50 33 27 22 46 41 59 53 47 65 44 77 14 93 64 67 39 55 57 15 32 70 71 31 95 94 39 79 31 45 73 28 46 40 51 14 38 88 93 1 24 44 24 29 95 90 22 5 71 69 40 22 48 4 44 97 36 17 17 81 12 34 71 27 88 17 92 22 13 10 64 61 25 17 22 86 10 43 58 72 52 71 33 26 90 56 29 50 81 61 43 2 81 55 50 53 51 31 12 21 55 56 34 35 50 1 50 50 52 45 25 26 83 72 44 95 70 11 85 78 24 83 69 42 5 82\n 86 82 57 24 65 19 89 35 47 22 27 67 24 67 15 69 86 77 9 78 45 84 29 74 75 48 50 1 50 63 87 8 42 84 35 63 8 91 55 36 95 4 9 56 38 62 91 42 11 10 7 32 21 97 83 74 38 47 58 97 38 26 38 51 16 32 94 6 58 93 5 11 11 39 30 91 6 84 34 96 23 17 83 43 2 50 12 1 13 73 90 61 60 55 68 48 73 78 53 23 48 76 25 97 84 15 51 6 60 61 91 14 72 73 2 55 44 37 57 45 94 69 69 2 83 26 33 65 75 59 23 41 79 34 48 73 68 61 82 55 16 92 29 73 13 95 1 52 55 66 67 45 24 6 61 25 7 12 20 24 82 39 34 33 82 30 36 4 82 62 69 25 95 51 99 91 63 25 73 35 27 62 29 98 3 12 12 98 33 50 75 17 79 40 44 40 41 55 33 80\n 47 73 94 48 78 95 53 12 31 67 9 15 36 48 41 35 19 47 54 30 81 42 75 71 84 32 80 21 72 13 68 6 27 54 48 51 7 26 37 20 17 58 73 51 88 34 19 96 19 55 61 59 1 8 31 49 17 30 5 14 37 82 23 54 59 93 43 21 32 39 20 19 33 10 75 98 27 21 87 44 68 66 79 88 20 91 13 16 6 46 33 74 96 3 71 81 74 28 27 88 36 86 6 40 22 83 90 10 7 44 7 66 46 3 99 56 62 48 93 70 25 21 53 47 64 54 33 75 28 96 67 27 25 8 31 59 17 57 96 42 42 29 69 39 82 76 12 58 72 97 88 23 22 60 29 85 90 1 73 8 56 95 98 55 24 84 49 99 75 68 56 54 40 1 99 69 61 26 3 55 7 97 25 60 83 63 44 59 93 9 86 81 57 49 27 29 20 13 91 72\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 519485142 10857 10761\nprocessing times :\n 68 55 10 91 98 1 14 84 84 77 19 80 82 74 8 16 9 36 77 25 72 1 94 58 27 84 34 98 96 52 89 87 68 64 34 57 28 70 95 24 56 95 91 91 32 23 23 32 81 4 53 78 44 97 79 65 80 49 79 30 14 62 5 74 66 34 13 78 97 81 24 32 37 61 4 33 93 39 63 34 77 94 5 90 53 84 36 3 19 59 54 92 96 10 36 88 60 4 42 85 5 62 59 60 13 58 4 29 62 43 5 2 16 99 84 67 14 89 7 65 95 93 13 71 74 99 75 49 88 23 8 8 77 61 15 81 23 18 32 53 8 87 78 30 98 88 11 36 10 3 8 67 18 8 18 9 83 40 21 30 1 87 73 97 13 66 18 4 50 54 89 84 25 82 22 27 44 38 8 15 94 65 67 15 48 41 57 63 76 11 66 65 46 6 63 72 6 40 95 12\n 48 64 13 26 55 85 55 59 79 37 54 98 44 36 30 89 76 18 43 12 75 84 37 34 55 56 1 79 12 40 29 17 48 79 91 63 34 15 22 42 36 37 84 77 79 61 90 88 36 21 73 41 91 58 69 90 18 80 96 6 24 11 52 74 78 76 78 51 89 96 49 97 32 48 50 50 70 8 38 24 18 68 43 6 6 13 86 71 15 39 86 28 4 71 96 70 29 24 51 4 4 35 77 99 63 30 52 42 56 98 76 11 13 14 58 45 29 47 74 62 32 55 36 93 26 2 87 61 79 49 66 46 68 61 33 73 87 88 34 43 42 9 32 25 39 45 16 96 7 73 82 12 88 56 20 96 75 34 98 22 52 35 97 88 56 64 93 69 10 31 59 41 38 13 94 68 41 95 57 41 25 19 45 86 6 2 9 20 32 61 48 77 43 83 88 3 36 13 42 24\n 71 5 80 22 35 7 98 32 96 1 64 7 44 75 34 42 90 79 43 98 94 65 53 65 3 29 2 12 34 32 19 73 42 59 10 5 51 63 59 48 56 46 80 68 41 86 92 10 46 86 43 53 59 49 77 13 21 39 85 19 24 7 77 86 3 31 82 91 15 25 24 68 47 56 80 54 55 23 68 6 83 53 88 8 97 14 76 4 81 10 23 92 93 69 94 70 30 81 83 81 82 7 92 17 71 80 47 69 23 24 1 62 70 5 79 46 36 20 42 43 98 10 22 97 67 66 39 60 26 43 4 31 11 51 58 74 76 74 74 25 79 62 43 74 4 79 7 69 78 69 44 27 47 35 48 94 69 18 28 99 42 15 76 96 15 72 92 64 12 20 62 86 30 98 69 60 78 38 26 66 59 2 18 76 44 59 52 86 53 97 15 61 96 89 22 69 76 7 33 93\n 49 54 4 99 69 85 44 96 43 30 6 21 81 19 21 70 90 16 94 78 52 75 24 36 87 25 96 50 73 39 69 5 76 15 89 16 86 16 21 52 84 44 34 92 5 20 82 45 28 16 24 32 31 70 54 5 57 66 83 61 45 32 1 74 82 86 8 61 73 16 16 33 90 73 7 26 7 97 16 22 45 39 85 90 34 20 55 50 77 35 5 96 72 39 35 15 62 61 1 80 55 68 35 14 85 54 71 71 84 78 50 81 38 23 35 69 33 90 8 19 44 82 50 54 48 16 38 94 74 55 59 81 72 32 5 18 55 78 33 33 43 28 88 74 54 65 44 47 97 53 19 98 96 33 40 46 25 18 40 82 36 86 83 29 21 73 12 79 87 96 88 4 64 9 97 32 9 6 57 86 75 81 46 21 94 97 10 35 81 31 48 20 97 35 65 52 85 11 77 18\n 42 58 93 10 27 12 69 34 84 53 6 48 48 48 26 39 97 51 86 49 68 85 21 71 90 45 63 33 38 64 5 94 82 38 68 16 92 50 3 22 75 34 46 38 45 15 97 94 93 53 49 5 18 10 84 21 84 31 68 44 88 5 17 62 32 81 99 83 13 4 61 59 19 57 66 53 72 88 78 61 91 65 12 89 29 67 27 31 66 57 89 91 22 10 36 98 7 48 68 15 11 77 46 96 8 12 61 41 95 68 39 52 76 26 18 5 72 53 30 77 84 10 60 38 64 8 6 89 5 72 70 27 55 66 7 48 38 87 49 71 1 84 55 61 14 13 9 84 87 69 24 54 10 93 92 65 53 80 2 63 24 82 17 33 18 19 18 1 44 4 79 93 17 86 86 90 68 83 89 82 28 20 96 71 92 47 12 93 51 54 38 15 19 73 98 33 34 10 9 77\n 91 90 58 87 90 92 31 79 38 84 53 52 56 68 63 36 40 38 39 1 92 7 3 6 20 57 76 61 50 40 38 36 69 46 22 65 11 49 19 56 50 82 34 64 69 94 10 92 25 45 35 19 74 26 54 24 33 93 46 22 68 97 38 84 96 43 99 93 87 49 70 45 56 84 24 37 13 42 18 50 22 67 5 56 33 45 91 86 30 76 85 83 24 54 21 27 54 5 58 3 59 45 53 18 58 47 36 74 10 56 71 14 73 25 25 84 32 80 92 96 1 50 46 80 97 39 99 48 55 33 79 98 1 80 11 16 87 78 16 16 22 28 60 14 26 66 15 41 55 51 12 63 94 14 99 23 97 63 32 99 77 46 18 55 95 64 14 95 42 56 31 78 89 97 11 14 21 74 9 65 33 21 52 76 95 97 79 86 58 93 89 88 70 45 19 26 16 10 45 98\n 95 50 81 57 99 13 39 44 55 74 81 60 22 60 11 82 5 14 58 80 14 23 67 29 23 46 36 11 11 92 9 20 8 84 42 7 32 52 69 67 1 9 87 25 36 9 2 99 12 55 84 8 26 72 31 2 56 58 48 60 35 17 5 31 92 49 86 36 85 23 15 62 6 43 61 52 47 69 88 68 69 58 69 47 19 81 54 54 69 65 44 45 11 84 95 90 28 38 83 38 47 99 77 78 84 77 72 37 87 19 93 82 97 81 37 32 78 40 43 85 19 87 11 62 40 57 35 49 58 82 13 99 73 89 7 50 60 23 59 98 21 47 14 89 37 85 83 25 25 63 16 39 10 89 8 71 90 90 30 12 93 83 36 54 28 30 39 25 47 36 64 57 27 62 89 88 21 25 42 15 15 42 66 28 22 64 18 73 64 35 59 37 36 29 56 38 69 25 55 84\n 88 74 68 60 9 47 55 84 48 85 45 78 17 58 47 79 45 3 71 21 66 30 19 75 1 30 53 83 72 64 91 93 34 10 3 43 65 57 44 85 19 1 61 80 53 18 74 95 82 96 71 89 36 73 93 38 55 51 77 61 99 67 72 73 19 48 9 52 51 95 7 34 5 74 39 93 79 37 82 98 54 82 56 84 76 58 35 54 74 83 43 4 65 37 28 64 12 48 67 54 74 97 50 26 4 59 32 6 54 47 24 3 99 80 34 13 51 81 22 3 88 50 24 26 96 4 24 71 78 78 88 49 64 72 1 36 94 40 58 65 97 89 10 39 45 93 75 12 55 36 25 71 75 65 56 16 33 66 29 9 88 50 51 21 48 57 1 7 33 29 66 47 59 9 25 50 43 30 68 84 39 95 56 54 8 25 37 11 55 80 2 35 38 15 18 22 6 55 99 62\n 92 51 80 46 39 93 85 57 29 25 36 36 1 5 9 32 30 70 11 15 90 76 25 92 8 3 96 4 49 72 67 77 58 24 16 94 58 48 33 89 36 78 26 68 78 67 38 19 86 74 7 56 59 35 80 21 10 18 95 70 91 92 6 90 35 59 73 15 87 93 28 65 2 18 42 22 55 18 39 13 68 99 39 60 68 62 43 40 50 38 10 53 5 30 34 1 6 39 55 23 49 8 56 27 22 94 31 85 2 96 98 60 43 31 66 25 14 77 64 68 59 77 86 87 89 33 90 65 36 77 73 41 28 92 12 76 48 31 2 55 26 25 48 43 1 95 77 28 24 98 93 97 66 47 30 70 20 97 94 29 66 11 22 84 3 89 91 25 39 49 68 93 44 90 93 42 46 68 37 43 89 57 98 46 67 71 81 65 53 78 3 52 97 19 61 5 76 66 60 49\n 8 74 55 20 20 25 75 14 3 56 57 77 85 49 47 28 39 97 17 97 62 23 56 95 57 5 75 66 59 87 35 93 47 47 44 56 92 38 24 3 32 22 72 16 60 21 29 81 34 40 88 48 91 93 95 62 10 1 35 74 3 97 87 73 48 43 32 75 90 76 17 81 61 86 87 69 7 38 96 11 86 39 25 98 31 60 42 19 53 22 42 26 67 31 38 79 13 8 87 83 66 44 54 51 79 81 17 19 47 32 27 64 61 74 7 79 50 61 80 42 48 9 32 94 88 3 13 65 94 96 75 15 99 28 45 84 93 94 55 84 60 82 27 76 53 91 26 92 28 45 49 62 45 18 66 52 43 71 23 70 34 31 53 75 51 84 90 20 71 51 60 75 52 84 31 92 27 68 16 14 39 13 52 8 63 98 92 87 98 33 11 35 28 56 3 72 93 53 43 91\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 383947510 10731 10663\nprocessing times :\n 91 23 99 12 22 38 26 67 57 2 73 71 54 75 65 28 85 43 40 66 35 84 47 37 65 11 81 32 23 77 17 46 41 85 74 82 87 62 49 93 99 84 45 98 50 77 25 10 69 53 39 62 75 81 24 99 78 6 70 75 22 18 87 37 17 20 84 7 84 79 29 22 29 44 74 2 23 83 79 91 17 80 39 64 30 73 7 53 98 88 92 31 46 92 14 51 77 65 8 32 53 52 87 88 44 20 89 69 73 49 93 7 62 4 54 55 46 37 47 43 20 61 32 85 93 23 73 12 76 38 13 85 79 22 81 75 7 27 87 96 45 94 12 39 59 19 12 85 99 81 5 17 17 30 36 73 87 44 37 12 97 47 7 91 24 76 76 65 97 32 99 83 70 17 88 42 63 54 10 3 5 75 92 13 27 13 35 63 4 46 60 44 88 64 13 82 67 33 64 19\n 3 29 65 40 51 79 20 13 12 19 84 15 56 80 69 48 75 7 5 91 25 9 13 18 59 56 57 21 25 78 73 89 3 26 81 24 86 8 66 25 49 87 31 15 99 1 52 46 27 17 8 84 94 36 21 61 8 9 78 19 36 68 61 68 11 90 5 97 35 3 76 9 49 85 10 19 84 71 8 67 23 11 74 32 37 52 69 68 34 9 5 69 41 8 50 18 97 49 57 63 1 73 39 41 87 98 48 39 74 87 88 4 98 19 94 25 46 27 70 85 42 18 92 62 22 38 82 48 23 98 25 73 34 94 10 73 47 95 18 69 29 11 42 98 82 98 86 96 90 24 6 18 43 25 20 34 34 58 47 76 79 66 12 26 95 27 74 4 82 36 38 9 76 69 18 38 72 46 57 45 95 26 70 37 42 31 42 88 22 21 83 31 72 17 50 37 33 90 85 88\n 26 31 7 88 75 15 37 10 13 57 68 91 32 28 98 4 77 28 24 54 13 91 69 55 13 98 13 74 46 99 50 50 26 22 5 79 33 41 78 15 78 40 23 68 55 64 11 42 86 16 96 67 97 34 48 55 59 14 86 54 19 60 55 1 28 59 70 51 67 55 20 56 4 30 33 67 52 24 66 18 92 5 58 65 67 80 27 82 49 8 53 18 31 2 17 74 4 53 48 18 52 41 23 87 6 44 47 54 84 31 33 44 25 2 56 72 41 9 87 79 63 40 87 23 3 35 92 55 6 80 27 77 99 63 92 89 16 24 23 52 62 72 36 2 71 62 9 40 93 3 13 34 54 29 71 67 59 77 64 19 63 15 36 53 8 39 38 8 48 56 96 68 47 95 43 54 58 79 3 36 9 78 28 34 12 72 22 54 54 16 18 76 94 56 31 97 18 72 12 83\n 16 35 98 8 63 68 18 80 68 46 21 4 95 60 2 56 50 55 31 69 73 35 10 75 49 33 41 65 83 71 37 95 46 34 59 50 65 17 93 91 10 97 42 95 3 86 17 85 4 54 12 10 61 33 70 97 55 78 7 72 90 38 37 30 24 17 76 35 36 26 75 69 67 80 47 40 82 87 86 29 77 10 43 97 37 25 23 28 40 69 31 63 1 92 78 91 36 30 96 18 42 88 28 99 20 31 49 39 9 11 70 13 93 60 12 7 69 19 62 44 25 96 22 61 54 95 72 67 66 44 6 30 42 21 22 65 75 71 92 90 4 94 86 75 61 5 89 27 65 4 98 89 17 20 89 12 96 98 48 37 58 72 73 34 2 27 4 45 1 30 99 75 87 31 81 61 6 22 27 26 28 41 49 32 60 22 79 96 88 61 46 84 80 98 99 97 60 89 5 70\n 53 53 66 74 76 6 76 95 11 15 54 47 94 55 63 56 74 93 34 8 62 52 11 50 27 73 87 7 31 63 83 79 19 6 36 31 28 19 80 5 77 5 25 13 87 8 92 89 21 56 49 75 59 70 68 36 9 9 25 2 73 73 32 60 25 12 15 75 56 35 78 15 35 22 10 34 28 49 26 29 66 19 33 9 92 98 35 73 91 69 35 92 79 74 90 90 58 99 27 90 49 19 57 4 7 5 36 89 87 75 38 19 83 64 98 85 84 89 38 52 75 50 77 41 19 91 14 12 82 33 58 8 97 99 27 1 1 15 50 25 85 40 26 93 17 39 72 74 9 66 79 77 10 7 62 30 99 40 44 86 86 97 60 91 87 6 16 6 46 36 87 66 43 15 33 85 55 73 53 35 46 81 57 18 43 84 95 41 81 31 46 39 64 36 37 94 15 7 93 61\n 43 78 80 43 75 90 69 39 76 26 71 88 46 42 97 25 37 54 46 46 81 34 90 81 38 27 88 42 76 60 7 38 97 48 28 6 93 8 55 51 65 93 52 36 10 8 50 93 79 54 83 85 33 76 73 54 89 92 58 47 71 99 86 67 34 83 93 20 93 31 22 39 90 99 66 61 86 72 22 2 98 13 34 37 20 18 45 49 58 93 29 98 85 15 28 41 97 53 25 72 69 34 89 15 28 2 54 1 28 94 2 11 78 19 6 48 34 61 3 26 45 83 41 93 33 40 93 76 43 15 41 79 58 41 54 98 89 95 74 82 82 71 2 62 86 79 26 79 51 52 27 8 5 18 10 17 60 50 94 96 20 82 45 72 96 30 29 22 88 26 12 80 14 13 77 7 27 64 71 92 46 92 22 8 6 69 55 13 11 84 61 34 48 44 15 35 40 97 10 50\n 43 7 16 2 19 96 38 90 72 80 21 77 55 94 67 73 20 25 1 43 78 61 9 22 43 23 10 22 3 82 80 47 59 96 28 50 8 43 94 78 87 52 6 44 37 11 6 32 70 16 63 39 18 4 32 21 75 3 77 2 53 17 93 57 78 27 3 67 26 67 64 70 47 34 58 56 74 93 84 75 89 64 46 12 52 97 29 49 25 5 30 8 10 66 61 80 52 16 80 88 80 50 24 83 10 59 51 75 66 6 26 86 50 6 87 18 65 48 46 54 70 9 79 81 71 91 80 88 44 33 66 6 77 13 79 99 22 60 30 95 40 55 17 51 24 85 94 4 21 84 91 7 36 41 62 54 65 63 89 81 90 35 91 69 29 76 40 60 28 4 22 91 70 66 41 23 13 58 54 66 6 3 60 71 54 39 69 8 85 72 63 56 1 38 88 94 55 87 82 31\n 5 37 23 27 78 86 81 49 88 91 16 25 55 34 93 22 78 43 98 62 3 15 8 2 11 75 65 37 76 8 76 67 95 12 93 73 31 68 46 77 70 60 27 58 25 72 72 11 43 80 74 59 11 76 64 89 12 64 89 87 73 14 38 94 26 20 9 38 77 24 49 95 15 8 22 43 95 87 75 91 77 30 49 4 48 82 18 34 37 27 52 56 29 99 82 35 50 79 83 67 53 16 45 61 62 88 84 3 44 70 26 94 12 54 79 18 55 20 53 25 86 50 79 94 11 26 9 17 99 91 53 49 71 33 31 34 92 92 18 73 33 98 52 19 63 33 59 37 71 93 14 35 6 72 37 34 64 81 77 66 41 78 70 48 8 56 90 36 24 81 85 77 46 89 39 49 40 31 13 30 71 27 68 99 35 38 52 18 92 14 66 18 9 87 60 47 23 10 33 32\n 26 50 93 73 76 46 81 9 53 30 30 66 75 32 60 47 26 23 79 36 99 99 53 11 90 14 81 60 86 5 44 84 95 15 75 72 78 74 51 87 50 48 70 62 84 81 52 7 35 93 71 74 81 94 44 33 94 62 57 89 67 5 15 72 79 56 87 14 46 68 90 84 23 10 64 45 54 57 34 28 51 35 82 21 34 46 21 86 15 16 93 21 55 1 52 5 23 54 31 56 11 87 46 70 25 63 87 12 23 40 22 31 79 4 47 73 54 44 45 48 39 76 67 26 75 70 89 49 50 63 73 52 49 81 7 83 70 77 39 61 58 48 34 58 48 29 38 8 88 29 74 70 7 64 26 58 85 65 44 84 56 54 25 93 37 61 16 75 49 82 50 86 5 63 24 32 98 1 95 14 26 25 8 96 23 75 95 9 21 70 16 7 96 54 50 19 62 56 95 56\n 20 68 70 50 40 87 59 16 52 60 35 18 1 52 74 95 94 64 31 64 91 37 33 90 58 74 68 87 18 31 72 19 67 69 80 63 20 22 6 86 66 99 59 21 37 26 73 69 28 29 41 26 76 77 48 17 71 5 28 24 47 74 94 99 98 52 12 33 18 77 85 6 45 8 18 19 71 99 26 89 20 67 8 44 7 23 35 32 88 35 90 16 40 51 83 2 8 31 75 37 27 39 38 95 29 49 52 6 26 89 75 30 98 53 66 95 72 89 41 42 95 22 79 93 72 77 46 58 2 71 71 42 5 43 75 54 63 80 97 70 22 85 93 39 18 95 52 26 5 28 46 15 5 83 96 25 64 71 2 40 39 4 47 75 48 39 34 76 38 55 26 4 90 93 60 31 73 79 46 10 14 8 33 58 39 94 74 92 16 68 13 72 27 22 65 28 82 6 58 60\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 1968171878 10438 10348\nprocessing times :\n 64 52 2 49 20 96 64 70 79 36 7 48 81 70 65 30 68 61 40 15 39 5 27 19 99 75 75 9 42 11 53 18 43 9 15 27 26 67 26 67 41 5 15 54 82 74 34 73 44 84 45 11 67 16 3 34 40 31 90 29 68 25 68 95 52 77 60 12 74 86 9 89 24 93 71 52 88 28 53 23 48 73 42 7 87 8 95 31 68 49 82 58 92 47 83 91 7 61 49 65 65 90 59 94 97 61 63 83 54 5 10 4 12 50 21 51 90 52 37 94 77 48 25 8 75 14 11 20 58 97 29 53 53 11 97 91 42 19 86 68 24 21 7 31 57 6 90 26 4 97 4 14 22 21 22 38 64 54 15 47 88 58 53 93 4 83 39 50 36 75 35 86 36 71 43 46 48 16 91 45 31 53 8 15 10 46 37 87 25 96 21 99 67 23 16 5 50 40 5 67\n 66 61 18 44 87 82 61 97 39 27 10 29 56 51 44 98 69 25 29 30 97 63 91 32 64 16 69 80 29 66 86 12 83 50 53 1 2 35 56 23 7 48 22 39 25 57 33 5 2 62 88 96 92 28 5 54 87 77 16 72 18 15 81 62 21 33 75 60 1 38 51 76 89 37 87 7 24 86 76 4 32 36 37 74 28 7 67 50 40 21 31 15 76 39 46 96 4 9 96 92 73 60 30 90 94 68 85 36 52 40 86 54 71 79 72 97 35 87 23 78 36 79 75 18 2 8 26 85 51 22 25 55 23 34 28 10 44 67 54 53 38 38 93 41 14 3 32 78 41 93 25 95 90 33 91 65 40 33 34 7 50 7 74 53 2 83 76 37 22 62 75 80 74 65 38 69 85 21 25 45 90 55 92 36 49 47 26 4 43 83 92 26 94 31 59 84 15 2 25 48\n 53 74 51 52 33 35 97 20 23 96 35 31 44 72 76 26 36 98 11 3 28 62 68 66 21 4 92 65 29 8 67 90 45 48 93 78 79 97 5 93 8 36 68 98 21 25 95 79 58 65 91 73 22 78 83 45 15 1 49 64 93 70 3 52 13 65 4 18 61 21 63 44 38 45 2 79 39 2 91 65 74 48 36 77 70 42 63 64 64 88 14 38 71 6 80 91 46 21 52 3 35 87 97 5 19 92 58 47 90 42 58 79 62 16 80 40 11 1 90 73 53 66 60 4 52 43 11 99 70 49 64 88 58 58 55 57 35 32 75 99 22 59 90 65 91 93 81 17 44 27 50 48 38 92 18 47 35 37 91 85 82 40 10 65 28 70 22 36 68 17 61 23 7 4 4 48 66 24 25 60 2 79 62 63 72 38 9 88 40 37 49 26 73 57 26 37 96 98 33 80\n 93 84 29 96 6 71 54 69 98 13 91 24 73 64 47 19 47 3 82 51 40 31 38 27 70 28 55 20 32 69 39 95 52 40 25 73 51 41 56 32 85 7 91 22 72 14 53 24 71 45 19 32 82 60 61 29 65 89 96 54 24 3 51 30 92 6 37 92 89 6 39 14 36 77 68 6 59 18 78 78 66 57 95 77 95 94 39 25 39 35 40 7 66 88 85 52 1 63 50 7 58 59 48 48 54 60 90 88 36 23 23 71 79 69 72 69 13 38 48 69 33 29 40 63 13 43 34 40 47 53 75 35 68 89 13 23 95 8 65 22 10 58 53 99 21 82 75 17 50 92 68 82 92 54 17 18 66 54 76 10 28 44 23 26 55 6 93 6 75 96 27 20 61 72 68 26 34 2 7 4 34 51 66 34 85 36 8 35 83 29 15 14 57 59 71 55 65 68 10 33\n 60 32 5 37 88 55 60 97 78 50 41 20 61 95 42 30 81 2 11 84 49 12 9 93 61 31 55 79 96 35 20 42 81 46 81 5 65 83 9 70 74 51 99 80 53 95 83 70 50 24 52 17 23 45 35 51 66 2 1 12 46 4 69 27 62 45 96 29 5 78 65 30 32 93 97 76 17 75 75 44 40 63 49 21 86 60 88 44 84 88 34 66 55 15 51 28 41 7 74 54 68 82 34 3 59 51 60 42 32 53 48 56 58 95 14 70 98 21 21 4 6 6 58 29 61 84 79 98 12 60 89 61 18 53 98 7 65 37 88 19 38 38 63 14 33 32 61 79 20 74 78 58 87 24 25 61 47 6 9 97 23 90 16 3 30 96 20 79 96 91 11 31 88 5 40 27 20 85 71 24 31 94 35 36 81 38 81 62 20 46 15 80 78 97 23 62 48 38 35 8\n 74 82 47 63 51 12 24 24 11 67 16 36 3 96 37 96 15 4 62 22 88 21 96 19 21 32 86 3 89 50 48 53 36 65 89 93 22 57 68 11 85 92 20 1 66 13 77 10 60 38 11 48 48 83 59 51 70 73 26 52 6 85 98 26 8 95 74 58 52 50 4 65 64 36 68 66 33 25 64 49 44 61 23 91 1 95 33 51 70 90 25 87 25 80 49 86 60 75 87 8 2 55 92 93 18 5 9 20 75 88 26 50 38 99 90 42 99 21 16 95 87 41 14 60 22 18 51 12 12 64 62 46 79 95 54 77 20 50 29 75 72 58 25 7 7 60 21 79 75 56 37 68 86 99 7 32 54 74 99 64 51 67 87 48 72 54 64 32 11 60 76 25 44 24 59 13 9 59 79 60 81 96 95 57 41 64 83 30 54 78 53 19 8 17 35 51 89 37 29 9\n 79 79 59 69 14 30 89 7 69 73 62 53 82 73 34 78 32 57 2 37 45 70 60 88 1 73 96 64 80 19 83 40 92 97 30 69 38 22 13 22 77 3 19 62 13 23 38 51 20 74 98 98 82 77 47 93 12 33 77 92 93 9 89 62 19 91 16 76 74 6 80 27 20 5 49 8 85 2 25 88 75 42 17 34 51 28 71 89 50 29 9 81 30 64 9 12 15 2 2 22 31 29 81 31 47 23 38 70 60 50 68 77 94 68 84 45 56 22 3 88 57 86 67 93 42 1 96 37 96 50 99 8 70 72 17 73 53 72 84 26 93 82 62 50 45 5 12 48 82 45 50 30 49 52 7 35 33 9 52 47 45 82 30 80 3 58 30 27 72 1 46 90 87 27 69 20 57 37 94 61 6 46 67 2 52 24 29 27 30 65 36 3 33 89 36 42 25 87 64 47\n 68 15 41 23 50 92 82 84 53 97 82 58 61 71 23 45 6 32 69 7 1 59 87 1 77 55 60 30 14 27 11 38 71 43 55 85 65 64 61 19 87 4 83 4 38 40 94 94 88 57 33 99 51 58 1 29 31 26 93 12 55 77 63 53 41 34 57 37 71 77 18 16 26 25 38 45 92 40 46 56 84 39 22 39 57 55 90 16 44 17 21 79 20 34 84 1 17 1 97 77 65 18 17 41 28 26 60 81 25 45 94 11 30 93 31 14 97 71 52 82 10 48 65 61 63 49 1 29 11 30 74 42 56 35 22 73 68 78 94 17 23 47 66 11 83 98 81 76 5 44 18 15 94 15 16 19 25 14 30 82 52 93 99 22 46 54 71 27 79 45 75 92 89 16 44 30 19 69 37 15 82 16 57 78 18 45 5 57 40 96 53 53 93 75 50 34 66 20 13 75\n 80 28 31 10 37 69 57 9 48 60 26 62 37 85 97 70 59 4 91 22 22 63 84 8 45 40 51 23 67 38 91 92 66 24 11 74 94 95 40 42 61 7 79 73 81 29 67 50 17 62 91 92 19 10 88 31 80 59 49 92 60 76 77 5 26 94 27 77 36 58 15 65 82 43 98 21 42 17 39 40 45 74 65 2 5 60 57 49 48 78 89 60 63 56 49 49 10 11 23 77 91 67 52 45 84 12 19 52 73 49 11 22 58 39 12 2 34 76 94 73 66 70 68 68 35 95 31 28 87 51 3 56 31 76 63 20 45 41 76 89 33 57 58 2 54 41 97 48 23 49 61 84 83 34 1 7 21 71 74 41 7 5 65 42 10 37 95 94 7 18 13 37 76 59 47 42 70 72 37 13 75 25 50 64 37 13 15 34 70 55 19 30 90 2 62 14 34 48 89 90\n 49 75 94 44 98 50 47 60 40 97 97 81 54 88 1 47 95 55 31 69 63 19 56 89 68 35 6 58 62 57 13 97 4 94 17 32 54 74 14 12 61 14 63 13 54 71 44 85 13 89 29 94 4 34 27 2 1 38 13 6 76 40 92 84 45 86 55 91 18 53 44 81 11 24 54 41 41 51 2 92 44 58 61 94 73 74 24 1 62 83 36 75 55 98 32 5 53 64 57 26 56 89 27 89 15 68 10 90 61 42 34 47 11 19 25 72 88 8 19 93 23 28 93 77 8 17 1 26 48 95 71 23 45 62 77 89 28 64 61 50 13 41 46 60 28 53 60 56 52 49 12 48 69 24 10 65 14 35 59 90 81 11 9 77 24 75 38 90 25 3 95 24 94 33 57 86 13 15 7 89 11 80 86 26 86 98 74 5 17 66 61 86 13 49 33 83 40 39 90 3\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 10 540872513 10676 10616\nprocessing times :\n 7 3 45 44 54 36 79 40 10 51 39 45 96 30 89 70 96 32 55 98 15 79 92 9 49 11 57 44 55 91 23 13 23 80 69 74 4 40 19 93 86 45 2 65 79 17 28 90 5 67 71 28 47 56 19 92 57 52 77 4 45 94 81 61 56 97 44 86 61 64 64 95 63 27 9 49 31 14 67 72 49 74 46 84 6 48 19 56 65 18 91 57 31 19 85 37 92 28 83 61 51 97 14 36 30 11 2 20 65 67 7 56 67 96 46 27 42 48 30 89 5 53 70 44 94 97 26 87 79 11 44 11 46 86 35 44 9 25 48 86 85 90 58 72 90 81 18 2 10 93 15 2 78 41 40 99 78 78 74 41 64 60 32 30 66 30 58 54 78 65 69 13 86 43 6 61 17 57 45 94 50 18 67 20 42 45 67 21 64 79 92 66 9 80 67 59 68 72 51 10\n 88 75 17 86 77 83 27 65 58 15 28 23 50 73 36 2 46 49 51 44 97 26 58 88 40 31 88 36 53 59 17 86 72 88 61 47 80 65 47 18 98 12 51 81 70 3 45 87 89 15 13 90 40 85 19 99 52 44 94 34 35 53 86 32 3 20 64 14 24 80 57 75 59 5 26 21 25 97 24 84 48 3 1 84 78 21 25 54 30 45 52 54 19 17 57 1 17 60 95 87 36 30 14 41 3 44 88 22 37 29 70 81 58 17 93 81 34 49 33 72 84 2 1 11 56 91 29 46 68 7 75 18 98 32 42 89 91 16 83 47 30 1 18 64 16 58 5 42 1 22 60 48 31 60 82 87 84 3 34 75 40 71 26 86 65 33 94 30 41 64 22 91 71 41 54 56 11 47 7 5 8 32 79 11 32 26 3 26 36 15 5 71 28 91 69 41 11 71 70 66\n 69 74 88 93 19 26 92 76 16 16 55 10 71 20 46 43 9 57 85 5 41 85 61 33 25 82 91 22 49 89 33 37 37 20 60 82 70 18 17 12 44 91 58 3 79 24 16 42 77 20 31 42 34 87 69 81 37 2 90 96 68 98 3 12 7 20 86 21 34 4 95 44 22 31 71 23 52 92 21 96 22 88 87 24 17 82 1 65 22 77 38 20 77 64 49 46 74 96 56 94 81 79 49 94 3 59 66 85 69 7 22 68 89 50 28 56 55 69 90 29 33 54 19 72 86 29 42 56 76 24 79 77 56 35 22 91 95 41 41 23 10 78 50 97 90 95 74 1 28 21 69 20 89 46 92 79 33 26 92 66 39 16 93 84 16 59 33 18 11 17 7 68 15 51 78 52 30 75 11 79 75 66 98 88 8 45 74 15 99 55 90 84 56 50 19 81 18 41 1 46\n 22 83 19 8 62 40 71 48 49 40 83 57 68 50 99 89 90 40 1 26 72 35 35 23 40 83 85 83 53 97 99 20 41 58 42 62 99 76 95 25 2 48 16 87 33 24 22 5 41 42 69 62 59 47 88 92 3 53 45 5 87 2 98 98 20 69 70 77 51 50 65 27 79 75 14 92 98 50 85 9 52 40 2 27 13 22 70 93 62 62 45 88 53 82 24 88 22 28 93 30 61 34 68 43 87 2 45 68 11 14 25 81 11 91 37 20 4 57 50 55 34 14 64 90 74 80 29 13 67 61 22 9 32 68 60 49 48 7 76 13 87 2 20 98 2 22 68 33 6 63 40 18 87 80 16 34 61 13 83 85 76 75 54 9 21 96 88 21 17 53 4 72 23 11 39 64 20 54 12 35 1 24 14 5 74 90 40 52 66 53 92 42 23 47 14 12 12 70 56 39\n 26 5 53 1 56 85 21 8 47 66 12 4 50 44 16 37 73 46 8 88 42 61 13 27 91 83 87 47 26 98 60 84 57 20 36 51 68 35 31 82 93 79 68 94 26 96 99 86 69 58 82 37 15 49 18 28 68 14 90 15 76 33 31 88 3 2 14 40 25 56 98 67 1 59 89 10 56 68 46 77 29 32 51 68 8 83 31 68 65 50 86 60 69 18 23 76 75 53 72 7 5 32 81 59 28 88 56 20 13 93 24 36 58 49 44 27 42 71 51 89 28 89 11 94 92 93 39 59 84 81 30 69 19 49 44 19 51 11 16 7 31 88 17 29 16 2 52 21 38 49 53 9 41 55 25 13 4 74 52 90 5 40 51 29 17 8 91 85 77 20 93 65 83 35 23 4 27 19 71 15 91 73 36 16 70 62 65 77 83 25 98 63 47 11 38 29 31 63 35 97\n 60 37 28 70 4 71 65 83 67 93 43 9 75 22 6 49 71 82 72 4 69 18 49 77 74 64 24 24 22 68 53 45 98 69 77 4 61 71 49 26 57 46 52 80 65 43 95 69 51 24 19 55 69 94 98 54 36 57 88 94 44 13 70 8 16 44 67 45 12 75 95 37 10 28 94 36 38 84 90 58 50 80 1 98 39 26 56 2 4 79 93 86 71 28 90 90 57 39 54 93 57 96 20 27 52 17 28 6 10 79 81 38 67 88 90 56 71 97 92 30 74 66 3 89 74 15 51 62 77 88 14 38 62 73 23 26 70 4 8 9 54 84 5 53 50 84 92 23 78 78 62 55 24 22 46 27 35 94 93 53 87 46 85 26 87 26 24 6 99 85 51 36 40 96 73 31 16 31 34 50 14 21 77 26 1 13 65 30 18 5 27 88 42 3 82 8 67 16 73 74\n 68 42 14 51 1 60 44 49 89 52 53 35 80 18 46 60 41 36 78 81 12 79 25 28 40 99 70 21 83 1 59 41 91 62 97 47 1 58 5 82 24 94 66 68 76 35 49 38 95 82 56 41 73 43 71 73 1 71 73 55 59 71 18 1 83 40 60 73 23 35 20 84 44 23 38 44 40 15 52 94 42 32 71 5 37 7 69 44 69 24 32 53 61 83 27 91 31 46 17 24 23 36 12 21 60 67 62 40 99 54 78 11 81 59 82 99 97 77 64 78 75 45 37 74 12 11 13 15 70 51 18 92 86 25 52 53 81 67 32 62 53 11 11 61 35 3 21 5 6 87 95 84 39 48 49 99 27 81 42 90 54 49 75 36 53 92 13 11 87 97 50 37 24 22 53 19 47 64 59 55 58 18 83 11 90 40 73 11 71 88 66 75 73 27 12 30 56 34 7 84\n 2 62 62 58 14 32 27 52 90 34 90 81 70 37 89 91 75 82 40 32 57 89 36 24 61 19 15 52 58 18 28 79 6 99 92 92 47 35 35 79 66 68 7 37 17 33 53 53 94 86 56 22 12 32 75 94 79 73 6 15 97 35 7 40 59 28 81 15 80 58 12 78 55 10 96 29 13 58 40 11 90 78 4 91 30 9 73 17 22 91 12 49 97 20 39 43 44 56 54 76 72 93 16 24 96 92 90 27 17 85 9 56 61 76 35 79 71 87 24 6 9 88 70 9 33 24 68 49 51 45 31 75 11 45 52 59 32 69 25 7 30 19 14 89 71 75 2 31 39 81 25 87 10 74 24 75 19 60 21 77 35 76 75 25 78 47 70 33 53 24 94 7 92 29 78 92 15 68 74 33 63 2 57 88 42 68 77 79 95 79 9 11 83 11 67 62 55 92 30 40\n 34 49 84 38 88 55 2 10 44 75 37 63 47 1 88 97 96 60 14 98 72 33 84 29 22 91 13 34 34 81 63 20 45 50 32 66 49 4 20 17 62 74 34 81 55 87 80 29 35 73 62 9 88 17 90 44 98 84 66 2 39 41 6 48 86 65 43 73 34 70 8 95 9 90 79 14 75 94 43 7 66 63 12 55 18 91 32 21 2 99 46 56 44 39 43 47 38 53 34 72 16 42 81 31 81 68 11 41 83 60 46 32 74 94 58 14 37 77 9 70 26 67 18 24 57 27 37 86 31 46 59 2 98 65 9 32 87 51 23 39 86 3 61 42 60 98 7 7 70 13 44 76 58 16 28 6 47 15 94 22 7 33 33 52 4 28 16 51 25 64 82 48 81 76 83 1 24 91 86 38 90 73 95 4 81 58 5 36 48 42 43 40 58 89 89 84 95 16 66 20\n 48 12 62 95 91 52 70 89 18 18 83 4 72 62 77 89 90 63 70 77 76 36 30 95 20 79 67 61 96 81 3 71 83 88 21 92 55 82 50 49 3 53 70 39 63 74 7 85 76 44 9 10 51 30 37 67 78 58 58 36 97 30 73 50 29 44 25 51 69 96 37 41 2 46 79 16 87 76 11 1 27 87 99 60 30 68 32 85 45 7 97 38 55 29 93 5 12 46 61 65 35 72 10 3 78 19 85 45 43 87 15 78 75 14 87 40 84 65 4 68 32 75 25 49 7 5 75 58 40 15 82 40 32 63 39 53 85 47 28 15 42 97 70 53 59 88 58 53 46 78 60 70 33 74 39 25 34 59 82 89 94 83 51 56 82 52 30 63 47 29 99 8 64 17 45 37 9 6 90 69 80 61 22 5 86 25 57 19 24 94 93 16 99 30 49 7 19 15 28 84\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j200_m20.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 2013025619 11294 10979\nprocessing times :\n 68 40 43 72 87 59 67 89 84 43 92 90 23 20 97 57 33 7 69 56 16 41 7 74 54 67 15 85 83 42 29 64 3 9 35 24 72 70 47 78 60 11 60 5 24 52 39 14 65 99 69 96 54 37 35 19 10 88 61 95 18 49 69 86 28 6 40 88 94 78 43 31 54 80 11 27 3 32 2 49 27 81 18 83 84 49 64 20 52 42 51 66 95 18 37 70 22 87 67 15 1 37 91 59 2 44 29 37 30 20 19 79 41 79 49 21 97 86 15 57 76 14 57 80 93 31 66 30 82 11 71 94 35 71 76 76 26 31 58 31 98 26 92 11 72 46 20 38 57 5 19 65 35 89 41 15 99 19 74 63 92 29 47 80 7 43 89 9 99 38 76 52 48 55 17 63 92 77 31 44 76 18 7 40 47 73 41 70 86 8 63 77 91 24 19 63 72 17 46 66\n 10 76 75 29 10 86 62 26 1 62 89 2 62 96 99 91 85 42 7 4 23 74 83 41 63 99 55 37 23 1 84 46 31 93 79 32 71 60 42 24 51 98 64 85 31 11 95 58 57 28 76 40 96 54 91 90 41 72 37 38 64 98 36 20 3 41 93 44 3 19 66 55 66 68 1 5 59 64 1 5 11 46 10 56 25 95 12 48 11 45 25 62 12 67 17 59 30 73 34 27 50 87 77 88 80 75 41 84 24 27 52 73 75 23 52 97 40 50 95 34 2 76 26 48 16 20 86 62 54 50 26 4 4 59 24 14 49 35 78 77 72 10 87 24 26 46 40 86 40 8 39 11 96 74 22 22 50 6 95 83 70 1 8 94 65 70 61 80 82 23 51 92 25 23 40 69 42 13 17 27 74 7 25 73 81 84 40 28 86 17 66 33 20 84 23 73 25 87 2 15\n 77 30 88 21 29 12 2 95 24 20 66 82 45 4 22 81 56 85 3 82 94 72 96 55 3 63 65 20 4 95 20 57 38 46 76 10 79 7 12 60 85 73 18 75 77 71 83 63 52 66 30 71 57 83 34 31 11 50 22 7 82 34 5 62 3 68 35 79 10 60 67 10 87 25 24 4 36 44 22 8 49 97 8 9 18 34 54 42 70 59 8 29 6 42 33 67 7 64 7 60 79 26 57 98 27 66 89 90 44 91 36 66 71 32 80 25 32 39 38 5 97 56 65 14 58 35 97 24 46 91 53 29 72 43 62 27 57 14 92 69 61 8 78 43 53 2 72 23 85 49 6 34 6 51 17 66 31 58 84 70 87 99 88 60 4 2 99 79 49 53 16 64 72 59 62 66 92 28 72 50 80 48 12 32 76 33 65 18 88 60 67 54 61 72 50 42 30 24 27 6\n 68 48 56 54 38 65 56 29 21 99 34 25 66 54 1 52 23 50 61 36 60 1 57 38 68 45 85 13 55 98 12 97 6 94 43 86 2 84 94 28 68 45 43 89 86 8 32 62 11 36 3 23 79 99 57 4 69 69 30 99 51 66 33 13 89 73 26 25 88 70 72 56 1 6 97 57 64 40 4 71 84 50 1 30 84 33 69 19 37 25 27 71 55 19 43 80 93 76 52 26 70 36 23 72 23 28 14 48 54 86 81 12 26 76 41 89 70 54 6 65 7 14 88 98 57 19 72 41 40 62 47 65 14 99 65 14 99 65 62 30 6 80 52 35 25 54 44 40 99 21 74 10 46 99 88 91 57 85 62 46 88 11 27 35 50 68 58 47 44 37 76 30 98 57 7 15 84 39 62 1 41 59 92 51 82 49 78 87 60 55 57 70 11 62 53 95 97 9 85 17\n 26 97 5 89 77 47 60 12 96 63 27 87 46 10 97 59 58 73 11 31 41 23 36 54 7 31 90 83 65 61 15 10 61 55 81 87 81 50 43 67 54 79 26 64 83 56 8 78 27 1 97 35 29 22 16 87 79 82 65 62 99 22 79 37 31 30 40 93 22 91 8 44 95 93 83 38 74 24 50 75 60 15 73 68 63 79 40 2 45 94 3 16 29 55 3 72 87 64 33 64 64 32 23 94 93 69 75 65 68 93 4 91 15 83 38 34 67 24 78 41 87 55 83 5 34 16 57 66 23 13 35 8 17 20 18 66 10 48 71 64 97 59 25 67 5 15 33 6 27 34 12 28 15 36 22 82 43 97 6 28 65 45 73 63 41 12 11 85 82 41 87 84 25 59 89 86 15 17 44 71 15 10 68 58 33 14 3 89 94 19 33 55 55 37 26 22 75 4 82 30\n 99 58 61 33 30 49 54 36 38 63 97 45 65 26 76 23 40 91 51 41 8 42 71 20 54 19 32 65 27 20 99 81 87 4 10 2 61 10 22 59 45 8 27 24 53 53 84 46 17 5 77 96 41 3 99 99 37 2 10 40 63 29 82 14 39 11 18 44 37 77 40 81 28 52 64 21 39 97 37 40 75 9 4 69 22 54 86 41 59 56 76 47 53 38 6 26 27 81 17 87 22 32 34 37 58 7 53 70 20 88 34 34 27 40 46 38 35 99 65 58 17 5 41 46 14 10 70 44 97 79 50 57 68 80 47 27 12 24 88 3 98 29 23 8 55 86 98 90 46 22 19 24 95 75 97 95 99 78 30 6 86 59 7 61 53 54 25 55 8 80 52 67 17 78 57 92 1 42 70 34 86 78 69 87 49 34 80 38 14 93 86 35 18 11 19 29 56 2 58 2\n 88 35 33 93 84 19 43 14 22 1 55 5 14 82 84 10 17 39 39 75 59 51 30 71 95 17 46 61 37 93 28 57 7 53 82 22 50 93 29 9 76 20 6 39 49 31 20 79 46 22 78 19 87 85 8 2 57 99 69 55 14 24 42 64 96 40 87 43 96 94 75 27 97 51 75 33 13 32 93 53 38 16 45 79 90 48 37 72 53 71 22 63 25 9 38 58 42 84 54 58 12 99 24 85 35 13 20 54 46 23 27 90 74 96 52 55 12 61 63 13 56 49 50 85 42 52 54 47 70 36 49 81 23 64 20 97 36 36 53 88 42 93 94 61 92 16 4 88 75 85 28 7 84 63 69 94 23 2 43 26 7 44 12 51 19 5 62 28 96 9 70 8 94 22 74 94 13 9 95 78 51 26 58 53 31 74 35 59 39 53 53 43 18 37 8 69 18 68 63 48\n 68 29 75 63 2 18 43 6 13 55 84 1 70 25 38 98 17 23 28 80 24 29 16 13 35 31 40 40 22 59 78 10 94 80 86 18 34 69 94 9 87 24 44 31 38 25 29 70 3 69 77 26 63 91 49 5 30 79 59 73 40 54 30 18 18 62 20 26 52 90 47 99 18 69 40 21 49 18 89 86 28 53 14 91 87 18 51 73 35 38 53 41 29 44 8 93 47 26 61 47 99 57 50 48 50 2 20 80 6 75 70 16 73 4 45 92 15 70 41 6 42 42 21 7 43 64 89 77 41 93 33 36 73 66 64 43 8 75 50 11 41 50 15 71 76 73 23 21 80 40 43 40 6 4 46 30 66 16 26 25 39 69 45 39 90 50 32 92 87 10 43 14 18 91 12 28 34 72 87 36 7 48 21 56 5 88 16 4 43 49 42 91 64 99 60 9 11 10 88 41\n 93 33 48 71 46 23 7 70 78 71 34 43 88 35 6 59 43 98 22 13 43 64 18 25 62 53 85 31 47 23 95 74 36 29 39 43 59 24 42 88 16 23 33 20 2 1 47 39 84 94 40 74 34 7 20 80 34 50 26 28 8 30 49 4 1 31 18 1 43 79 98 87 72 70 26 23 1 68 31 62 48 17 69 13 14 42 37 21 12 37 95 42 3 21 75 15 5 21 51 99 38 55 80 36 39 99 59 35 1 96 64 84 38 79 75 12 46 60 33 81 13 86 5 76 12 46 39 91 86 49 7 56 75 73 58 88 3 40 56 43 27 93 30 36 10 98 65 49 59 76 10 24 84 11 8 33 54 90 30 51 24 4 51 16 67 21 90 9 18 6 72 33 54 27 46 52 69 34 29 92 14 62 39 27 4 96 63 15 62 63 40 72 30 30 91 94 88 89 99 63\n 10 99 37 79 24 82 12 84 49 15 48 58 9 74 22 43 84 18 30 86 53 87 79 83 93 7 78 31 95 32 55 46 3 93 36 77 67 29 70 34 45 16 99 70 48 86 31 88 69 10 54 12 10 74 86 56 82 40 93 10 59 11 35 84 88 40 78 57 21 5 68 73 13 71 35 13 71 76 28 13 52 58 31 53 12 24 83 71 49 78 15 24 6 72 48 3 49 81 15 13 36 94 3 35 37 48 66 31 4 6 23 48 50 41 23 57 5 5 23 21 58 96 9 40 2 55 2 9 78 37 52 78 18 85 79 6 23 47 82 66 24 14 9 37 1 33 94 82 60 79 4 69 92 51 7 36 96 40 15 53 90 19 19 97 39 37 4 25 63 95 12 55 89 11 38 47 45 27 2 98 89 24 58 84 33 24 71 25 14 37 45 30 27 43 36 88 44 20 29 48\n 9 93 84 58 14 31 19 16 41 9 67 74 85 90 77 40 33 42 74 16 45 62 44 68 76 76 78 29 15 30 93 16 38 27 32 31 88 79 86 61 30 55 8 90 70 58 35 11 66 63 26 92 29 98 59 18 39 1 27 4 38 42 69 4 68 30 39 75 87 45 83 30 55 37 31 74 49 18 76 46 78 99 58 84 89 74 1 86 95 58 17 18 70 49 21 43 26 67 66 89 66 63 88 45 52 89 83 80 58 52 21 34 96 69 81 65 61 82 75 61 22 52 10 50 30 84 86 16 54 54 70 37 18 96 80 80 21 58 70 71 62 4 1 4 69 70 77 28 47 78 64 58 47 17 67 84 59 51 47 61 51 97 65 7 71 75 47 83 1 46 54 76 54 59 37 47 55 76 75 23 41 28 78 58 51 40 16 21 88 59 3 39 73 34 45 20 66 35 96 24\n 79 2 54 78 71 65 95 21 18 54 1 87 29 19 38 44 46 25 48 66 81 42 48 34 73 32 68 60 63 49 19 54 14 40 83 66 27 89 69 34 27 3 97 40 57 3 45 42 1 63 14 29 53 5 71 44 57 77 43 59 25 52 19 34 16 38 61 53 36 87 3 56 1 4 4 98 90 23 78 64 90 18 19 67 82 16 53 18 17 25 71 12 24 32 44 39 40 47 53 75 83 35 53 1 35 67 26 13 52 31 11 37 13 73 37 56 55 81 61 75 34 2 29 2 60 17 55 3 94 70 35 71 62 92 39 47 10 72 5 40 1 15 67 10 31 40 7 54 86 4 2 89 36 33 98 70 91 64 41 19 24 84 50 51 60 3 56 79 8 34 93 79 72 7 90 2 76 1 7 57 19 2 11 84 9 88 50 52 49 10 23 30 75 43 88 66 23 34 1 82\n 44 40 27 41 9 77 98 64 14 2 19 9 19 28 69 90 71 83 2 16 9 60 1 44 25 86 45 68 1 56 64 7 68 96 30 62 32 25 27 97 54 28 65 7 71 74 8 46 76 45 11 92 54 31 51 48 27 55 39 71 18 48 8 35 62 52 65 95 55 7 37 91 91 73 56 22 98 96 82 84 31 44 19 60 19 56 6 45 24 10 6 44 57 43 1 42 20 83 57 34 67 64 92 35 55 99 23 52 30 6 81 91 89 45 33 55 74 46 50 29 2 80 12 63 96 88 47 21 30 44 64 51 95 57 96 62 11 8 92 1 51 32 96 88 15 5 56 68 10 89 43 4 51 84 35 53 82 41 62 78 72 32 17 9 67 74 27 55 76 1 41 73 89 2 45 99 37 74 95 78 48 95 11 28 21 8 88 29 60 2 47 15 1 64 55 32 49 20 33 68\n 84 1 47 60 31 76 12 75 90 72 8 86 86 70 46 52 31 36 10 19 85 49 61 10 26 38 97 71 34 74 12 77 16 55 90 61 43 42 81 1 8 51 16 14 25 92 98 28 97 38 95 78 48 66 18 19 25 79 90 26 48 81 95 37 6 86 83 67 74 91 99 55 79 46 10 52 22 39 8 13 32 4 7 47 34 1 12 93 62 11 81 26 31 41 5 40 11 56 67 49 92 8 79 5 72 77 60 21 23 51 16 73 59 20 83 9 60 68 14 67 86 35 58 13 55 57 14 79 72 27 42 59 58 36 63 1 45 10 8 66 62 95 88 69 38 30 60 33 87 91 48 46 18 31 22 2 96 56 17 49 87 35 69 66 69 30 30 77 98 55 78 45 84 47 58 24 56 50 53 12 43 73 3 32 91 25 44 55 97 10 42 73 74 16 47 68 9 92 4 48\n 35 3 9 71 99 89 92 60 44 59 8 51 60 35 5 81 67 70 79 7 51 1 38 91 3 88 88 6 68 26 38 93 89 85 82 99 47 60 4 41 86 12 19 80 37 55 59 55 26 40 22 72 90 39 60 14 92 47 90 43 15 8 24 93 40 68 68 67 41 72 72 73 44 34 24 19 27 31 80 4 94 3 31 38 44 87 77 2 66 20 79 89 90 84 40 8 65 80 50 89 29 98 45 66 64 86 75 64 83 12 69 7 27 20 92 28 36 2 86 71 34 74 86 68 94 78 38 77 69 56 12 64 99 41 25 58 20 86 58 13 20 11 33 55 5 71 62 50 93 74 6 39 90 5 81 28 33 78 95 82 38 41 4 94 44 10 28 33 66 16 45 51 89 69 23 9 8 43 64 15 15 26 48 9 11 56 75 75 63 17 93 38 22 22 17 24 93 17 48 27\n 18 77 73 91 96 10 58 70 42 21 11 88 91 78 70 53 51 96 27 47 30 37 63 61 73 80 5 82 49 11 79 78 57 47 91 92 94 33 52 12 37 47 39 4 50 90 58 46 14 84 97 49 33 48 68 36 66 6 54 16 7 35 64 18 8 61 41 65 71 34 35 92 70 65 76 71 81 32 27 95 49 51 65 17 91 23 17 19 28 70 67 40 81 54 52 38 6 8 31 98 14 17 31 37 85 84 7 54 40 95 97 44 4 46 10 63 76 23 95 73 78 46 40 34 92 42 56 4 63 93 72 63 62 30 91 96 53 19 40 14 16 66 54 54 64 86 31 99 10 2 74 29 77 14 30 14 48 1 4 71 54 30 42 43 33 32 12 68 8 82 27 59 20 60 76 44 29 68 24 46 94 79 68 49 85 87 17 99 76 81 52 24 57 8 36 67 57 66 5 69\n 75 43 70 11 64 88 94 9 29 58 90 78 63 34 71 49 69 97 10 43 22 16 31 22 62 14 11 46 85 59 73 22 70 52 70 45 45 37 2 90 2 40 70 93 44 71 83 13 3 99 27 98 62 17 35 71 94 58 77 29 61 41 47 2 16 41 59 27 18 33 1 99 3 15 45 82 20 11 90 65 73 71 26 97 50 43 7 78 27 50 70 65 96 27 66 18 96 66 82 23 69 28 95 38 89 19 6 52 70 4 81 1 36 30 13 90 30 66 28 36 38 48 97 56 92 93 81 24 38 39 33 7 75 43 92 44 35 2 96 28 13 67 61 71 20 54 53 75 58 74 65 21 60 72 4 85 47 80 71 26 73 36 38 13 66 82 2 76 29 90 36 32 84 78 94 45 14 72 3 18 58 87 30 73 71 5 77 60 6 61 23 29 2 67 69 38 37 80 51 34\n 89 41 16 7 84 53 56 71 40 17 33 3 51 76 2 63 84 55 3 82 46 58 24 57 59 86 39 55 69 36 98 82 44 70 67 74 61 38 87 35 37 98 26 49 12 52 49 92 43 75 83 3 99 87 60 92 75 53 30 59 95 85 63 21 78 72 87 52 39 93 22 82 21 65 81 59 73 74 33 53 47 69 11 31 69 67 3 21 29 28 45 2 53 36 5 79 76 32 87 4 44 8 16 93 93 64 65 1 40 74 59 21 79 9 2 70 88 3 95 77 76 94 90 67 27 18 49 3 79 12 6 72 46 7 56 33 59 86 33 28 84 59 54 99 30 14 65 34 6 91 89 80 34 35 91 44 52 73 93 98 30 20 58 34 14 46 61 73 87 41 9 57 82 17 19 32 47 89 2 94 17 98 13 84 12 66 90 86 83 75 67 33 40 56 21 43 1 92 4 44\n 52 89 39 71 72 71 68 42 94 83 14 76 90 14 83 3 1 12 51 46 2 92 23 69 65 30 48 70 15 62 48 19 49 5 22 45 15 29 65 72 45 53 8 11 21 46 95 42 66 23 39 86 4 95 8 41 85 66 68 37 51 46 93 59 14 25 71 15 89 94 61 5 45 52 9 70 50 44 79 64 47 4 59 45 91 35 71 63 94 86 3 77 37 84 50 97 21 42 6 19 96 51 53 95 76 95 50 52 27 97 96 88 92 33 23 38 37 11 6 55 40 1 69 96 76 46 66 8 84 62 95 30 20 90 66 76 46 38 41 83 43 37 93 80 68 92 94 21 68 53 76 40 4 89 52 54 87 86 20 15 61 25 85 58 6 40 98 93 78 55 75 97 52 27 32 81 73 29 34 35 78 29 45 25 54 74 77 85 64 2 27 81 17 31 37 20 69 59 39 13\n 32 78 84 27 32 84 74 72 85 60 55 60 8 34 54 47 60 8 39 42 10 62 52 65 32 61 9 25 15 56 3 13 59 95 93 49 67 17 39 91 60 90 94 53 25 12 63 75 63 7 80 16 39 37 7 1 38 48 38 39 83 27 14 46 46 59 12 20 7 85 74 49 48 6 73 57 44 41 35 68 61 1 16 37 70 26 76 87 42 26 22 2 81 55 12 47 26 91 37 41 11 82 26 57 33 21 37 67 22 33 47 3 55 19 61 38 63 42 20 62 45 78 57 31 33 71 73 87 46 21 52 95 66 24 27 63 48 43 87 44 87 58 24 50 33 62 56 86 58 42 84 35 91 49 52 86 45 62 3 50 83 57 8 88 10 88 50 22 49 44 6 26 34 40 26 49 93 77 38 15 50 15 22 88 42 63 56 61 64 63 30 4 21 95 20 30 86 95 82 10\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 475051709 11420 10947\nprocessing times :\n 93 6 64 1 63 66 33 92 51 61 32 24 79 19 10 11 90 52 15 17 65 70 75 93 44 32 52 59 42 23 26 35 18 36 24 8 85 6 68 89 79 64 42 89 38 91 30 40 77 9 17 41 8 30 40 12 26 3 52 31 57 38 67 92 49 41 99 77 67 22 9 91 76 53 71 88 20 6 68 22 23 92 61 40 77 56 73 59 49 66 53 37 46 44 59 91 30 41 44 4 84 58 92 51 82 84 92 51 41 45 73 65 89 79 72 97 63 72 60 65 93 87 56 76 88 67 94 81 63 51 92 14 97 27 36 3 54 36 84 12 69 80 60 79 83 39 79 67 31 53 67 13 80 94 18 19 61 91 37 15 84 27 66 85 41 65 95 3 14 76 8 28 43 33 6 1 4 32 23 44 28 38 56 10 15 75 64 94 93 27 56 17 51 67 69 40 20 77 59 4\n 24 56 70 62 77 73 88 32 28 50 36 84 15 69 25 16 76 52 79 7 47 15 70 75 66 45 99 93 63 61 72 79 82 14 28 29 45 11 22 89 16 4 76 72 59 19 99 53 7 53 94 43 91 4 71 16 43 49 96 36 77 84 61 14 31 76 38 10 38 67 66 96 15 28 53 71 26 12 38 61 47 88 80 12 4 67 52 71 79 38 5 47 51 47 87 8 8 41 57 80 69 95 19 67 24 47 13 83 84 79 68 73 46 16 20 52 31 49 8 81 76 12 5 5 32 96 30 1 44 98 34 5 32 69 36 26 91 85 61 75 33 16 95 34 74 19 84 95 35 75 1 96 41 36 86 16 37 87 49 72 98 26 19 63 50 52 80 45 41 31 54 33 11 51 96 40 89 66 89 35 67 19 15 4 60 59 86 65 16 98 55 91 38 77 98 76 74 38 88 91\n 45 34 81 34 5 97 76 19 95 26 16 38 12 15 60 98 10 33 19 96 95 53 6 9 35 84 17 83 55 31 54 54 80 42 44 36 12 88 98 34 89 36 7 13 64 3 22 9 60 72 1 13 62 26 68 9 30 64 19 52 93 96 31 30 84 95 21 72 40 57 99 92 19 15 10 80 74 60 21 93 85 23 13 80 48 90 33 52 81 18 51 46 99 91 98 54 90 91 42 46 67 70 8 64 62 73 12 69 57 90 57 10 53 34 80 83 14 24 34 30 27 55 48 64 93 40 96 28 39 1 74 1 99 77 21 71 98 55 58 79 87 16 69 58 98 8 49 15 29 23 65 20 92 30 9 40 86 53 78 20 96 43 5 18 76 24 1 8 85 79 28 67 28 37 38 39 38 40 21 84 81 36 90 2 90 37 47 67 94 93 15 85 72 18 68 78 29 68 85 84\n 81 25 34 97 55 21 52 80 64 76 36 52 22 90 77 71 65 51 89 91 28 14 2 89 34 12 62 82 19 72 25 16 59 97 20 89 18 89 97 24 67 81 38 46 17 24 38 23 68 49 53 12 39 76 63 11 9 87 59 6 79 81 70 38 69 50 9 94 9 27 87 89 47 57 69 52 99 98 76 32 85 79 22 28 52 36 55 67 5 79 49 18 2 31 40 2 28 64 67 85 35 13 74 63 52 34 15 22 72 64 82 86 43 94 95 32 48 6 19 88 39 49 42 17 92 29 38 68 39 30 83 44 80 5 34 28 18 85 29 28 62 49 7 79 40 16 36 16 20 3 16 8 52 7 59 8 82 63 50 80 49 68 19 51 56 37 91 60 48 93 11 29 87 3 18 63 86 29 99 99 25 40 61 60 75 56 52 53 15 38 57 98 20 69 66 22 22 72 93 59\n 65 92 45 18 69 98 75 33 6 89 56 65 28 93 40 88 2 39 61 46 18 63 98 8 30 30 97 10 85 48 13 47 92 50 67 85 24 60 76 74 8 86 20 78 34 95 13 37 82 9 95 55 25 69 91 9 13 12 48 91 19 43 64 72 28 95 11 43 73 84 99 4 69 16 30 49 35 12 80 83 56 69 72 96 54 32 66 53 50 35 9 43 75 48 1 64 36 60 23 36 32 9 44 60 19 98 95 64 82 52 61 18 90 68 35 81 58 49 14 2 95 93 37 25 9 63 68 95 75 97 53 31 97 68 67 36 13 67 16 15 49 72 10 26 40 80 40 48 77 71 56 14 93 56 19 28 63 86 18 54 85 82 90 11 85 18 35 50 1 63 80 93 88 81 83 50 24 55 40 61 30 78 5 24 8 50 92 25 28 81 43 70 76 77 35 47 12 69 85 44\n 79 66 38 19 95 72 58 92 81 74 5 55 78 94 88 47 6 14 48 62 93 93 39 4 72 8 47 56 12 93 14 83 82 23 85 42 37 3 68 20 89 68 92 48 70 45 11 88 39 40 61 2 26 16 64 8 38 38 27 3 57 32 75 11 51 61 54 40 85 12 93 52 78 29 68 45 13 92 43 4 54 93 26 28 79 19 54 1 4 31 42 32 48 37 65 27 47 39 94 14 15 24 11 90 63 39 70 94 24 39 1 81 71 2 93 43 60 27 20 80 65 74 78 46 13 29 69 74 73 58 42 96 81 14 14 34 27 18 90 49 35 28 19 36 66 91 59 55 16 44 18 62 84 20 31 93 49 44 5 5 78 15 3 19 51 36 12 20 87 25 44 32 52 99 93 12 81 96 25 1 31 67 76 29 61 87 74 90 96 93 93 73 77 93 64 69 72 17 71 82\n 74 75 33 56 37 32 34 18 52 84 69 3 63 78 70 62 13 92 30 41 29 75 38 28 11 67 69 84 10 33 46 39 67 63 95 72 31 93 1 49 45 86 16 76 18 96 67 97 34 4 96 62 11 48 46 7 47 30 68 9 7 75 27 97 36 12 94 36 9 94 47 16 6 22 89 95 40 3 54 97 26 60 65 96 81 12 56 68 14 71 87 78 38 13 81 31 7 26 71 82 22 62 11 86 94 76 81 66 97 40 34 11 56 96 61 70 69 49 34 81 60 28 91 31 98 12 23 58 17 78 68 63 63 97 38 50 62 41 84 86 82 56 51 1 97 60 26 90 42 3 53 90 25 85 27 70 86 46 27 37 53 32 55 23 97 22 29 6 48 39 51 29 18 12 54 68 75 33 7 98 85 70 67 88 79 30 81 72 47 24 4 83 36 49 45 12 11 28 47 33\n 73 54 47 24 56 17 12 67 5 61 54 86 13 78 30 87 87 75 26 38 34 25 94 37 7 45 43 85 65 53 14 11 7 99 7 98 96 90 17 23 91 35 8 26 85 57 33 34 69 56 41 74 37 53 18 76 84 77 69 49 65 65 79 39 74 93 63 9 42 35 23 15 73 53 33 55 36 72 58 94 35 33 55 89 97 10 43 98 22 74 1 28 54 2 39 90 15 60 83 41 39 67 14 39 53 17 23 43 79 55 1 98 20 22 80 93 23 55 66 34 46 92 91 62 75 51 33 76 8 58 25 40 33 20 84 5 87 54 66 74 90 96 95 9 2 8 41 97 92 77 46 41 71 40 31 98 15 82 10 8 24 2 77 50 11 93 53 26 28 24 83 78 81 59 91 70 8 66 49 44 13 83 62 39 48 34 25 93 91 32 51 61 80 6 95 98 17 81 74 62\n 65 20 14 16 26 68 99 21 14 31 47 39 51 24 77 83 84 3 18 63 42 6 54 84 38 13 7 16 73 63 60 7 92 53 5 56 35 57 37 98 5 54 12 82 24 13 18 41 49 66 89 37 5 40 29 91 88 16 83 6 15 93 62 9 93 33 26 57 42 9 76 58 25 76 47 65 24 9 45 78 13 50 42 21 70 61 11 10 38 24 21 87 13 15 7 7 97 1 38 41 22 82 87 79 94 38 95 99 33 81 94 43 17 1 52 84 51 20 74 93 73 38 33 38 85 78 15 47 75 21 49 8 50 88 96 73 66 13 81 17 1 47 72 41 88 52 56 80 8 87 21 40 92 79 50 12 10 85 83 8 68 68 17 86 61 91 41 21 77 46 59 32 35 96 7 70 81 97 2 45 73 18 73 70 93 43 58 43 78 42 27 92 85 65 32 66 65 57 10 53\n 71 37 16 89 58 2 37 79 50 95 25 69 42 69 13 46 66 2 28 5 15 34 61 4 16 71 89 29 13 14 78 33 1 40 83 90 41 27 78 50 76 19 2 14 51 94 96 50 66 61 52 8 49 85 89 34 53 74 58 37 85 84 79 11 89 62 29 91 10 66 46 47 58 18 14 99 50 2 80 78 62 27 91 42 84 5 30 28 6 46 8 49 29 94 80 59 23 91 36 97 45 31 52 84 64 42 73 86 48 2 5 99 57 69 78 58 99 23 42 8 5 82 45 99 67 26 80 71 29 90 9 20 33 70 19 19 66 54 93 34 72 66 29 4 12 64 89 89 53 37 16 83 24 89 87 89 6 73 69 47 6 98 59 38 4 88 41 25 35 7 51 46 20 39 54 81 15 49 85 26 48 88 74 64 91 6 33 19 86 49 86 39 34 95 76 92 50 1 85 4\n 4 64 34 65 43 59 53 10 74 16 56 31 43 60 38 9 55 45 98 38 5 74 23 38 99 66 14 5 9 90 60 47 59 27 56 9 1 33 95 94 30 63 96 24 20 17 78 3 29 7 30 15 66 83 23 81 30 84 64 38 55 73 80 28 12 9 54 1 30 12 51 91 30 3 57 2 80 45 2 14 56 36 24 71 2 31 11 70 63 22 18 12 65 38 54 58 6 37 30 65 30 35 65 75 28 5 35 26 64 53 85 94 64 48 66 31 68 28 46 3 85 54 62 86 23 61 93 40 25 28 67 35 20 48 15 53 95 28 72 32 36 82 11 19 29 6 58 93 49 14 38 63 23 95 94 72 73 71 78 9 54 52 47 44 38 48 47 30 18 69 25 27 77 15 64 91 87 63 10 64 26 14 82 13 79 27 55 47 47 85 15 47 53 60 56 3 78 66 58 27\n 33 59 66 38 13 96 61 42 76 82 92 55 71 96 89 86 10 99 96 96 59 56 80 84 54 9 71 89 51 93 93 64 31 61 19 70 29 84 22 57 90 77 25 12 57 14 47 60 64 52 68 78 75 42 65 6 5 56 76 12 42 55 31 55 56 81 34 43 8 44 27 13 44 93 73 44 25 48 85 96 96 99 24 22 94 86 45 13 19 57 21 92 12 62 69 69 91 27 25 81 26 8 34 89 10 78 86 70 21 55 48 45 87 21 35 73 10 62 29 84 79 55 36 39 7 53 30 16 53 82 25 97 12 6 67 40 92 3 66 5 6 10 21 70 52 89 64 9 55 76 14 28 65 89 47 2 42 80 9 4 63 91 71 34 75 12 38 8 7 38 59 90 78 52 99 5 4 73 87 21 64 20 79 70 81 41 78 14 17 19 59 13 46 15 62 69 51 76 91 38\n 17 65 14 84 4 68 26 73 20 64 24 25 58 43 67 6 64 9 27 60 10 49 26 99 71 16 94 78 67 80 89 39 70 54 80 11 47 45 32 37 20 82 47 26 55 80 63 42 4 80 63 96 74 64 44 67 35 64 58 35 98 29 7 35 79 70 10 84 5 23 62 75 1 75 93 65 93 85 55 2 53 63 61 9 72 27 98 40 9 50 90 46 75 92 5 49 9 34 95 79 71 72 43 28 28 25 66 45 81 56 34 28 44 1 65 66 53 48 65 14 51 8 12 63 8 46 24 93 27 4 63 21 4 92 96 87 10 82 57 47 80 95 42 47 24 88 59 44 58 98 15 2 51 65 39 71 6 11 37 79 42 69 34 5 13 70 49 94 79 90 17 94 22 22 51 97 49 75 28 7 91 10 32 10 72 94 72 29 58 82 48 10 68 61 89 32 5 50 83 38\n 91 34 58 98 2 59 30 59 56 56 95 73 48 77 15 73 94 13 92 24 68 64 32 69 24 54 31 20 59 46 79 76 28 46 37 5 66 77 97 68 68 45 52 30 95 49 58 68 11 44 69 16 1 57 87 7 52 27 33 53 40 71 18 83 4 80 11 35 61 72 90 58 89 32 82 66 69 24 90 64 28 44 20 66 13 23 57 24 19 60 57 53 46 14 92 66 91 13 73 92 4 2 88 93 64 99 90 20 7 73 61 35 80 78 37 40 50 53 61 6 44 87 66 14 23 1 80 34 22 40 63 31 32 64 13 2 47 60 73 75 95 35 17 70 4 59 68 75 24 21 22 4 8 1 32 68 33 27 11 57 23 17 43 58 7 30 43 29 41 27 80 43 84 40 65 94 63 41 29 36 94 18 59 33 93 97 97 94 31 33 85 21 80 6 75 65 62 48 22 68\n 90 99 24 24 90 76 93 50 82 34 35 40 99 78 40 98 8 15 64 47 76 75 16 57 23 10 86 90 84 77 93 34 45 71 51 19 28 48 52 60 25 47 81 6 73 94 46 7 50 82 26 95 17 71 51 45 10 17 35 46 18 21 80 79 12 77 25 75 35 80 54 69 20 75 38 13 57 80 65 46 91 59 67 9 3 49 7 39 26 93 25 12 88 70 32 14 30 63 58 28 60 30 78 40 23 20 69 99 96 61 79 1 61 72 65 61 35 7 52 94 14 74 19 46 9 40 61 56 21 95 6 95 27 63 49 14 66 3 1 50 1 67 97 41 13 30 53 84 29 21 16 49 17 30 69 33 56 41 64 2 99 87 10 18 39 55 46 96 54 84 98 8 18 91 9 57 86 97 31 10 48 45 86 81 21 40 84 40 49 24 28 25 87 54 86 10 79 23 5 39\n 78 20 36 28 14 83 35 87 9 51 6 73 88 62 77 38 69 38 81 42 10 87 78 22 90 57 5 39 90 87 76 84 37 41 54 22 68 9 30 38 32 56 17 36 42 38 48 26 56 16 37 66 24 63 73 56 30 1 69 81 51 48 57 53 94 81 64 43 72 99 85 36 93 3 47 78 56 10 43 1 35 96 32 86 27 60 9 34 73 25 83 54 13 37 3 2 48 17 75 66 86 83 7 84 33 10 29 91 46 42 1 43 72 62 65 72 65 74 57 88 76 67 58 37 65 52 29 94 61 69 63 46 46 64 33 72 4 81 40 17 72 88 59 92 30 40 81 94 44 80 48 2 10 48 71 98 92 24 91 83 8 11 86 2 45 40 65 94 96 99 59 27 10 62 22 72 56 48 20 58 74 79 54 46 97 9 96 67 55 11 53 71 8 62 22 57 65 91 24 9\n 87 4 16 7 3 43 26 80 19 12 61 25 58 10 9 57 86 72 32 81 35 4 62 2 31 99 15 96 21 30 24 57 91 1 56 97 22 29 56 8 86 52 65 22 52 38 86 30 55 87 92 55 46 85 47 28 2 87 12 85 69 44 85 71 32 49 31 2 55 71 92 53 56 91 61 39 84 40 18 19 62 41 26 7 81 25 19 85 21 6 68 24 97 63 13 48 98 24 37 64 59 1 8 39 67 11 87 56 87 64 48 84 9 7 37 90 37 75 97 40 27 79 75 70 85 81 64 46 15 22 1 29 3 9 41 3 74 69 66 37 49 30 8 99 50 48 81 26 7 99 68 38 59 42 36 59 50 63 96 68 78 82 83 79 67 15 86 87 22 80 64 35 30 84 89 78 24 41 42 32 63 77 46 61 58 77 12 91 63 86 16 41 96 53 90 2 95 3 82 19\n 18 38 11 84 41 23 9 44 7 85 26 17 47 2 24 77 28 8 9 11 20 4 95 19 85 18 82 45 4 61 35 98 59 78 63 8 86 56 6 90 31 52 96 1 73 43 52 43 78 10 63 69 14 26 77 51 8 30 70 64 75 53 4 90 10 83 29 87 58 33 18 61 15 10 52 96 2 75 41 22 29 23 69 82 29 30 5 84 26 7 92 55 73 92 88 27 11 74 33 6 2 73 63 19 64 23 11 66 27 31 46 12 67 43 24 81 52 36 41 28 23 73 14 28 26 83 28 38 7 10 14 50 26 54 97 1 91 91 1 18 6 15 84 44 60 65 3 7 26 53 22 36 54 19 67 6 7 42 63 55 18 15 91 43 55 55 56 6 94 97 23 85 29 55 57 82 42 24 68 50 67 51 52 29 90 58 97 94 4 42 79 98 29 6 66 89 42 84 34 84\n 25 19 37 58 87 31 54 94 96 60 93 55 44 73 72 14 78 15 54 84 66 36 94 42 8 51 55 78 58 22 64 76 13 33 28 17 37 75 32 57 93 18 24 87 66 56 95 39 49 55 80 8 49 73 33 85 42 43 27 6 26 37 45 85 39 54 12 20 60 34 55 25 38 12 39 54 68 48 44 15 37 16 98 74 13 68 57 40 59 22 15 94 28 42 72 91 1 58 67 32 89 3 58 73 90 54 62 75 19 53 86 35 59 49 13 57 37 33 57 57 91 92 29 15 65 85 6 43 50 43 76 83 10 86 6 86 11 56 62 17 72 87 38 76 28 47 17 16 82 55 65 61 29 5 11 89 33 94 68 21 62 93 81 44 40 6 97 54 76 21 53 52 35 92 12 92 12 56 28 1 7 31 30 15 44 98 80 77 34 31 5 90 27 37 46 68 4 82 26 23\n 56 54 13 42 93 73 3 53 41 39 41 65 69 60 99 86 26 97 62 49 25 17 29 91 85 55 25 94 48 64 73 49 19 37 41 12 1 93 69 10 46 88 43 10 97 75 43 34 66 61 10 99 7 93 85 89 74 92 73 92 9 6 16 34 85 48 79 77 76 57 34 50 17 90 6 38 43 45 77 61 16 13 4 39 74 85 97 56 28 81 84 16 5 23 70 58 9 81 60 65 84 69 76 34 14 31 98 30 53 21 37 66 93 21 65 79 11 85 27 41 45 78 56 89 58 51 21 15 94 29 83 23 22 19 23 12 37 68 24 2 59 13 32 58 60 78 31 77 2 94 75 44 55 89 78 63 50 93 21 8 64 26 84 4 14 48 21 4 98 72 96 26 42 99 21 29 55 94 99 1 70 49 17 57 49 92 14 11 67 33 27 62 57 57 72 68 18 33 93 84\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 914834335 11446 11150\nprocessing times :\n 83 94 45 44 35 62 19 81 70 88 4 33 82 74 35 12 47 7 88 91 81 61 40 91 58 83 68 2 98 18 60 77 92 83 39 98 55 90 55 88 63 69 18 32 8 39 30 64 10 8 40 55 91 44 43 96 55 96 5 32 14 90 23 57 43 12 28 55 35 18 10 53 51 84 63 41 31 93 64 35 38 2 94 64 40 7 95 20 9 18 54 65 1 7 19 96 69 24 66 90 18 64 88 44 1 72 66 41 2 22 52 68 2 42 92 95 25 60 3 38 13 57 94 3 63 21 19 55 45 75 55 36 25 37 90 95 13 97 93 12 83 40 87 84 59 34 30 89 45 87 11 97 64 64 12 26 57 56 68 15 15 73 55 77 19 83 24 47 39 3 94 65 46 46 34 48 91 11 34 49 49 56 34 45 49 37 66 47 53 52 94 59 42 55 11 27 81 81 64 48\n 47 54 84 82 96 28 69 70 77 8 69 59 30 87 57 42 85 75 2 56 92 91 44 39 29 3 62 85 33 28 72 90 67 31 44 46 53 95 76 66 37 70 33 56 24 71 78 92 2 86 30 33 39 93 58 90 14 88 64 56 67 16 62 74 4 17 57 40 75 29 96 49 81 48 88 14 37 34 38 87 4 82 76 26 58 71 50 54 22 37 81 87 94 28 42 4 88 76 73 12 86 98 28 40 6 73 9 15 73 56 28 96 68 52 18 12 46 74 25 17 59 79 36 5 50 20 74 88 84 42 98 83 16 38 31 8 14 13 67 48 64 21 34 83 41 63 3 80 18 45 86 2 72 72 13 75 62 73 8 80 19 66 54 57 90 65 26 48 3 29 80 74 51 17 25 29 24 60 8 5 52 61 43 30 36 21 2 7 4 56 98 2 36 93 66 2 53 55 28 52\n 75 98 2 14 37 66 26 76 43 49 80 71 32 58 42 70 8 49 29 47 81 93 25 9 76 73 58 27 91 7 1 9 50 80 89 17 67 91 41 13 79 2 42 7 66 26 51 47 28 52 73 27 45 31 70 88 10 24 65 85 11 17 89 14 92 39 2 85 92 78 38 93 56 57 97 54 48 56 69 34 90 43 67 9 20 3 40 97 84 84 95 51 64 85 77 51 87 82 52 25 98 17 13 43 1 42 47 86 31 71 63 97 11 54 50 91 20 84 85 65 56 72 60 65 74 97 4 53 30 24 81 95 40 30 60 97 67 43 19 25 97 53 6 44 58 29 66 61 32 58 86 92 39 90 51 34 56 11 80 27 2 44 53 87 12 40 70 5 23 65 43 80 89 37 38 49 86 52 38 55 95 16 60 61 67 13 67 73 78 82 2 23 32 1 70 28 6 12 99 35\n 13 59 32 22 94 19 97 97 68 89 13 74 65 48 30 67 73 93 33 48 40 69 38 8 70 6 96 29 26 91 92 25 80 10 19 1 61 52 71 84 83 33 41 16 50 53 36 68 98 66 79 21 39 82 89 81 53 59 28 20 71 86 85 33 27 96 61 86 83 76 53 71 70 75 12 43 66 17 87 85 29 82 56 75 82 60 73 44 99 71 27 59 2 18 67 63 71 47 92 15 24 76 79 83 82 25 25 34 31 82 57 8 13 22 63 5 63 28 71 56 86 46 14 38 47 68 27 44 43 38 27 12 45 44 85 77 27 67 35 80 88 96 41 12 96 39 47 36 89 77 21 79 36 39 40 25 65 26 66 19 33 34 76 62 40 90 72 32 97 14 99 71 11 63 72 45 56 53 24 81 56 54 48 56 58 38 23 37 14 48 26 37 23 73 40 84 6 61 17 78\n 97 2 95 40 81 35 93 7 49 40 53 43 75 94 46 86 95 10 68 37 31 45 51 76 41 16 30 32 72 58 25 71 20 58 6 19 28 72 19 51 42 73 32 26 73 23 29 47 24 19 79 35 97 77 91 17 54 7 15 95 42 26 50 49 22 33 96 48 20 66 12 38 6 97 88 58 13 42 40 6 66 10 79 99 18 88 93 56 94 43 33 82 10 43 11 27 10 62 28 24 42 58 26 84 97 65 32 22 41 13 62 14 64 1 94 83 4 32 10 81 49 32 31 20 39 28 49 45 28 73 18 8 98 68 1 66 28 61 19 97 15 16 97 98 12 98 69 6 87 59 40 1 65 1 40 57 55 14 8 42 51 51 91 16 43 28 70 48 56 13 32 95 12 64 56 68 1 50 34 62 25 78 35 45 16 47 41 21 42 28 34 51 64 20 38 50 91 30 27 65\n 5 91 71 97 20 72 7 53 63 86 7 44 34 15 44 35 41 65 19 25 12 60 72 96 19 39 42 73 35 15 48 24 10 10 78 11 24 51 66 16 10 97 93 65 51 13 55 17 89 98 81 11 71 98 60 97 57 60 47 95 8 62 8 83 27 76 64 36 60 62 69 19 15 48 9 73 33 4 17 73 23 31 93 18 77 86 29 25 5 5 20 95 57 74 49 60 58 68 43 93 95 64 13 63 18 26 22 30 72 24 28 46 67 66 59 34 95 28 70 77 11 34 34 62 83 6 97 6 69 38 15 65 36 26 95 19 3 17 3 45 26 81 97 39 52 17 61 97 44 94 9 71 3 41 78 27 91 24 26 80 62 28 44 84 66 85 24 50 91 63 42 72 28 37 89 64 33 50 58 8 79 2 98 21 68 95 29 99 53 77 40 32 99 47 12 79 96 12 96 97\n 99 65 45 35 11 25 28 31 88 98 19 75 77 54 13 11 4 69 4 4 9 78 66 69 86 97 44 33 7 61 65 73 74 26 96 62 88 14 79 2 66 1 77 14 91 61 33 18 23 74 70 9 29 35 62 86 33 84 63 69 86 96 84 17 77 72 93 97 54 63 61 26 8 69 56 47 53 66 14 56 71 60 58 27 88 26 88 50 67 57 11 50 81 94 34 25 4 19 73 29 9 23 53 75 16 8 87 71 75 32 58 57 57 48 44 66 47 97 90 63 8 34 84 3 70 10 18 71 67 12 42 47 42 78 96 2 10 18 84 72 47 67 22 41 28 74 63 35 32 60 56 22 64 77 36 32 62 53 75 26 28 68 61 90 43 83 9 74 76 90 26 56 96 92 74 2 3 62 17 54 26 25 42 17 73 9 13 23 64 85 10 95 84 68 40 14 91 76 89 80\n 42 70 87 86 62 87 99 65 32 68 31 95 4 95 16 87 36 99 88 32 98 30 3 55 86 10 88 29 20 3 52 56 38 31 93 19 69 72 36 85 16 57 44 99 84 87 81 25 11 2 33 86 81 50 45 20 32 20 28 36 98 96 28 3 80 44 74 28 50 1 47 46 98 76 84 87 77 99 23 95 50 44 70 77 36 29 40 43 33 31 70 72 47 83 20 15 91 93 44 7 31 26 88 52 74 72 34 12 84 71 10 12 42 98 29 18 43 11 19 65 65 25 11 21 39 72 41 46 11 88 22 47 20 76 8 85 56 82 78 20 21 78 13 52 70 3 51 46 54 99 70 1 98 36 80 51 31 63 37 80 93 94 8 60 57 19 55 67 42 91 82 20 36 87 21 66 50 18 70 22 11 64 21 48 34 64 44 71 15 4 97 55 90 2 56 48 64 75 90 50\n 77 2 18 67 11 42 64 6 9 72 96 41 61 22 91 74 95 55 61 47 75 94 68 34 10 6 31 15 1 54 14 71 81 82 47 7 45 4 58 80 95 32 29 8 47 5 75 33 38 80 6 8 28 86 41 16 61 74 29 92 59 53 27 59 93 89 22 46 81 35 32 59 30 23 76 77 89 61 69 66 84 80 4 57 54 27 3 50 94 76 20 40 62 98 88 87 46 5 52 89 78 55 20 11 27 83 55 3 58 87 16 65 4 89 93 27 39 42 43 61 20 93 42 84 35 68 4 7 86 95 18 4 70 47 56 42 35 83 42 95 70 91 19 60 88 50 51 59 51 69 86 71 12 63 85 49 58 33 83 20 33 38 11 41 79 13 31 30 35 77 9 83 9 73 10 47 7 5 31 3 37 99 29 46 61 37 21 91 44 89 60 62 54 91 66 77 55 17 44 11\n 74 16 88 2 43 11 6 78 47 13 76 16 20 69 76 89 50 71 81 18 48 56 78 69 97 66 7 85 9 7 52 58 13 94 54 55 27 46 19 82 61 90 80 8 9 58 8 43 66 69 86 91 59 65 57 24 76 15 16 63 5 11 2 58 80 24 35 47 4 40 41 32 60 45 84 29 72 3 1 11 20 2 14 78 96 57 81 44 74 10 23 94 42 42 9 7 93 89 57 77 96 52 74 71 93 3 22 89 2 15 3 80 88 52 41 18 97 55 58 32 71 45 45 86 39 25 23 96 37 27 84 19 49 21 33 14 51 87 19 14 32 84 83 81 29 91 40 39 10 40 55 51 94 47 26 31 3 94 61 75 75 58 45 34 90 83 56 23 95 85 76 48 39 44 88 38 15 25 25 25 84 35 28 83 12 40 78 32 17 15 50 41 13 68 42 67 92 59 70 33\n 89 97 1 77 90 52 35 52 5 67 44 6 98 14 2 86 53 14 68 6 20 37 74 58 80 40 78 23 54 12 43 33 56 39 17 93 16 45 63 22 87 72 65 46 79 61 30 76 64 47 32 95 41 54 68 63 90 23 94 78 82 53 57 51 45 3 31 59 97 55 99 94 15 72 51 49 59 82 21 38 53 28 84 61 29 29 24 43 47 89 15 55 75 55 34 26 60 66 88 21 38 7 50 55 69 26 98 99 81 63 17 23 92 28 78 94 4 98 61 74 20 21 79 29 56 24 9 12 42 77 38 3 50 36 4 96 51 35 27 97 2 65 32 14 44 4 45 69 62 57 28 17 44 83 94 78 34 54 4 81 73 27 14 43 29 35 25 40 39 3 60 16 69 17 93 49 24 13 28 51 91 44 55 3 32 99 23 96 63 91 94 6 25 56 49 98 97 6 77 88\n 52 7 77 29 8 53 30 16 7 4 73 55 5 26 14 30 92 16 64 20 3 46 58 18 99 67 40 62 11 23 24 27 86 32 26 97 12 61 78 77 75 35 5 32 47 89 95 62 68 39 46 84 28 42 22 43 68 7 45 18 40 89 77 57 37 72 36 58 17 84 80 33 83 76 28 76 41 85 21 70 3 41 65 86 66 74 75 1 12 99 59 91 40 5 38 14 41 78 99 38 31 27 38 81 59 71 83 80 78 20 6 68 72 24 95 63 84 54 6 33 39 69 58 51 44 59 7 27 74 3 51 44 68 84 20 47 7 85 92 35 2 94 23 33 7 3 23 63 94 68 15 86 51 83 45 67 68 14 23 40 52 68 87 56 68 44 99 21 82 91 18 71 28 85 70 85 19 1 24 43 39 74 47 47 92 87 42 9 37 70 61 27 18 20 33 39 1 83 32 1\n 37 71 68 90 51 73 84 86 58 98 84 84 21 49 12 16 52 81 86 91 35 60 9 7 80 17 30 84 76 38 48 57 79 43 82 55 46 82 77 56 49 88 13 99 84 18 74 49 54 31 18 48 88 43 14 90 33 62 86 83 14 8 73 33 54 75 67 58 60 43 62 4 49 80 35 47 68 55 21 44 72 81 64 78 70 60 61 50 37 13 6 36 38 20 23 59 3 63 81 1 51 92 5 6 60 68 30 51 1 8 2 55 78 35 51 19 94 85 40 50 61 52 79 94 48 99 47 30 18 81 17 4 22 21 35 44 2 48 85 60 37 7 62 14 83 26 13 50 72 58 74 42 88 65 1 79 25 42 8 27 39 43 53 30 11 87 25 78 63 27 61 35 15 73 67 94 51 76 52 93 31 22 73 62 27 16 81 55 29 92 45 75 63 81 18 68 60 2 48 30\n 4 73 56 2 60 55 13 34 79 62 19 15 25 6 43 26 15 92 82 65 94 30 20 37 26 81 31 96 42 40 41 85 59 67 11 41 47 22 91 17 75 72 76 45 67 57 87 23 88 78 78 52 4 39 71 19 45 69 3 63 48 49 28 74 7 54 69 31 1 33 82 30 39 81 66 68 87 48 73 70 11 80 90 99 20 48 17 59 15 40 37 93 98 53 35 91 7 34 55 43 32 68 56 55 71 41 16 40 73 54 65 8 90 74 35 1 66 99 99 1 17 93 60 43 50 37 28 43 3 83 72 86 19 49 67 54 75 36 6 68 37 9 35 24 26 97 89 92 94 86 47 83 7 72 50 20 98 98 90 66 77 89 23 64 57 42 83 90 63 26 22 94 26 22 54 74 62 57 3 53 20 60 87 66 18 83 65 42 49 3 65 78 54 12 74 88 15 71 35 41\n 94 24 98 6 7 4 99 99 9 32 37 60 31 64 19 84 71 1 95 55 45 39 95 88 45 16 5 87 72 35 86 50 62 2 82 17 68 24 24 80 44 55 57 4 31 65 59 21 95 16 22 52 8 93 19 71 93 42 28 91 51 14 62 22 23 83 63 84 34 66 49 61 51 91 42 39 80 96 9 31 29 97 50 8 26 72 92 21 3 36 50 80 57 15 6 89 29 89 75 98 83 69 26 53 50 20 22 39 85 63 58 83 92 48 3 20 58 10 5 16 74 35 21 68 26 77 94 29 17 35 72 27 84 93 16 71 18 99 3 90 89 65 16 15 53 69 55 22 61 26 74 18 66 40 70 95 28 84 51 25 40 53 88 20 38 99 40 1 73 6 65 99 62 53 26 64 36 77 29 10 2 66 25 91 9 46 75 73 61 19 73 2 35 12 27 15 41 83 15 35\n 26 65 92 54 52 75 35 2 63 90 2 4 87 25 70 48 92 55 11 11 50 6 62 83 30 34 16 8 27 88 82 73 31 66 20 99 89 41 40 75 94 17 37 70 3 15 92 6 84 56 56 6 48 9 87 86 22 68 67 28 55 59 88 90 78 17 7 73 43 48 67 3 60 14 17 60 56 68 15 99 82 55 82 61 96 57 15 84 46 78 42 23 69 99 5 14 3 41 19 74 26 85 10 97 27 49 11 62 10 46 84 48 54 81 71 26 66 19 73 78 56 32 54 98 22 61 35 32 56 23 78 90 37 63 93 85 56 6 15 46 59 22 84 60 1 76 53 34 43 58 85 50 60 99 76 1 60 66 50 6 70 30 76 95 92 87 90 51 58 81 21 69 10 90 79 64 74 21 16 12 32 44 89 74 81 96 15 91 98 83 73 74 92 24 75 16 88 82 63 70\n 18 68 87 65 53 10 88 20 39 88 35 73 51 81 95 6 8 89 64 76 67 58 64 65 45 65 60 75 55 31 96 36 49 20 1 82 85 16 57 20 56 7 35 52 98 34 19 36 8 35 21 2 61 26 4 80 98 14 75 23 68 80 91 14 98 98 80 5 91 51 17 27 37 32 75 84 59 30 21 52 44 45 10 50 10 24 60 52 84 30 68 92 70 97 87 29 56 74 2 88 62 95 47 84 86 91 83 27 2 20 34 47 26 1 93 15 54 9 77 47 54 87 51 33 11 15 92 95 66 57 48 5 23 44 66 76 83 96 94 9 28 48 11 30 30 11 8 68 89 55 37 57 69 76 66 48 53 85 34 70 88 70 12 73 15 37 39 82 20 88 8 26 82 29 83 40 12 69 77 22 61 63 88 29 42 22 30 63 60 8 60 98 74 85 82 39 26 29 31 70\n 68 26 80 17 81 66 38 56 46 57 20 59 58 39 56 96 38 63 3 71 36 92 33 95 84 79 32 62 73 5 37 42 49 31 22 98 71 72 81 10 60 7 19 91 66 21 35 10 16 67 40 20 71 57 12 31 97 75 27 62 53 1 96 64 54 48 42 22 97 32 78 54 51 44 91 37 21 80 66 20 68 24 19 91 78 69 35 16 81 35 94 41 52 94 40 81 90 38 9 6 77 67 37 20 59 30 70 69 33 80 41 89 6 22 20 96 93 23 47 27 85 78 1 1 54 95 3 67 87 80 19 5 61 10 42 75 47 49 84 19 62 9 54 57 55 35 46 45 70 90 87 58 51 39 73 44 54 53 19 85 72 10 66 96 68 10 1 20 81 68 91 67 14 94 96 18 80 32 99 68 95 13 47 64 5 53 92 9 46 85 76 59 5 39 9 12 40 71 69 6\n 79 49 63 1 24 5 38 42 20 9 78 99 68 26 1 12 97 55 36 68 68 5 41 70 20 49 58 99 9 96 41 67 21 88 26 4 29 99 80 30 57 25 89 40 91 57 44 37 99 71 76 71 2 76 83 80 4 25 86 62 37 28 38 32 82 98 22 92 26 60 8 71 54 46 58 13 42 19 97 18 61 59 24 10 48 45 1 8 72 23 93 7 74 25 7 21 29 84 82 26 32 44 5 96 10 47 33 59 17 60 88 46 95 74 32 94 22 95 37 7 23 46 39 41 60 68 8 62 69 64 13 50 47 9 31 31 84 92 19 45 93 12 19 78 64 93 69 96 59 91 71 22 26 49 77 67 68 93 85 96 60 5 10 3 49 44 13 45 89 10 94 32 6 40 37 68 11 94 13 66 69 7 28 27 86 68 94 10 66 52 46 70 69 30 78 99 78 53 16 63\n 26 43 63 14 66 8 9 38 19 15 68 34 39 31 88 57 3 79 49 63 81 13 47 70 31 51 86 82 73 50 97 60 13 43 2 91 63 94 89 8 1 22 92 27 44 13 99 68 79 8 75 26 19 16 70 48 71 55 10 40 21 44 87 52 12 76 41 40 51 77 59 64 58 68 90 36 16 61 90 92 48 69 31 70 26 55 25 4 9 41 76 69 55 57 70 40 19 28 64 19 30 5 65 68 24 47 58 74 34 10 82 40 10 40 78 8 73 82 56 9 88 30 67 82 27 38 74 9 83 86 9 98 72 76 76 15 91 6 11 81 88 7 10 41 63 22 20 18 24 58 67 72 70 60 18 67 10 66 11 68 38 63 82 96 62 26 64 18 65 64 3 29 65 62 68 35 77 84 46 76 67 52 98 74 51 39 18 18 65 74 4 22 16 61 38 37 77 19 1 38\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 810642687 11347 11127\nprocessing times :\n 39 3 69 34 88 15 10 19 69 68 57 52 97 57 48 3 9 36 37 3 12 90 35 17 77 12 16 68 43 58 6 91 99 92 77 4 57 80 13 70 2 13 8 34 7 46 9 91 23 51 31 65 81 70 17 35 64 14 56 22 57 5 68 66 79 23 47 70 23 49 72 7 11 59 65 50 19 14 68 32 62 93 99 24 86 86 51 60 57 87 84 25 84 16 86 4 10 90 23 34 49 89 57 9 27 89 60 27 29 12 51 20 91 31 50 5 77 65 65 3 99 92 58 17 60 5 90 43 59 13 70 28 64 50 11 11 38 23 97 65 26 26 17 43 5 87 59 40 65 90 60 37 26 83 47 81 92 95 8 24 90 2 62 45 28 2 90 9 31 65 65 31 6 3 38 98 17 37 6 21 84 53 67 28 10 50 91 34 68 52 30 14 37 31 86 9 31 90 53 64\n 69 57 41 24 33 29 3 6 35 10 55 75 20 44 18 18 40 32 29 54 64 96 21 33 97 48 48 6 36 10 46 92 14 97 87 15 12 8 37 61 51 66 53 33 16 96 6 6 15 52 83 87 35 67 67 53 32 23 8 86 91 92 98 49 28 2 77 42 68 35 96 94 25 84 24 55 14 7 76 17 38 50 2 12 41 11 63 27 63 27 70 33 73 21 52 14 16 72 64 55 88 51 23 53 40 53 45 45 9 74 5 71 72 63 88 77 7 88 39 30 70 95 79 70 92 12 21 34 11 92 50 3 33 39 49 25 16 48 56 52 78 93 74 68 41 5 14 92 46 18 95 90 10 88 7 57 95 67 84 55 70 26 58 81 45 19 95 19 98 74 31 70 17 6 28 84 45 96 9 63 80 27 31 38 68 91 89 15 10 61 30 15 91 78 52 70 21 57 28 14\n 77 72 43 37 92 83 25 61 45 64 12 58 19 48 18 41 48 69 42 34 11 68 88 76 97 35 15 75 83 86 76 70 28 81 82 25 64 10 54 25 44 40 8 62 35 16 8 90 39 53 60 48 71 12 5 89 62 70 72 75 97 2 44 80 40 10 96 11 58 77 6 30 96 59 82 78 13 13 85 88 14 45 76 9 6 47 16 92 4 74 7 91 52 81 86 36 22 72 95 87 30 86 10 10 44 95 68 97 79 80 21 55 71 12 86 81 94 47 78 54 74 2 28 42 90 79 78 83 56 8 43 38 95 87 79 16 39 61 19 75 92 89 17 66 34 87 25 20 58 57 85 69 13 13 63 62 38 62 75 79 65 8 39 40 13 85 90 82 62 93 29 40 96 6 82 85 34 18 62 56 32 39 14 63 40 5 10 49 98 96 39 65 52 33 4 47 72 70 17 72\n 17 81 27 4 73 31 15 19 94 65 83 36 53 16 81 24 54 74 44 66 20 18 6 12 91 20 42 70 48 24 83 70 23 57 39 83 46 60 67 61 57 94 35 23 93 68 8 17 54 96 54 97 70 84 31 93 25 69 20 38 36 40 67 28 91 2 69 55 47 46 24 91 51 27 8 98 25 33 81 75 61 22 61 35 19 26 45 11 63 89 55 68 30 89 8 90 46 55 78 32 25 91 69 96 29 2 25 61 3 83 38 38 94 36 3 23 93 93 75 77 35 84 24 7 40 4 18 25 5 56 96 93 10 33 82 91 14 46 38 73 16 52 99 63 45 68 2 72 22 52 1 72 95 26 30 93 51 2 75 39 99 20 68 40 77 57 57 13 43 45 74 98 80 46 7 40 5 79 40 48 38 4 48 33 94 32 89 85 84 86 84 78 77 15 71 67 70 67 80 58\n 25 3 11 17 56 29 73 30 95 54 67 28 84 79 43 6 87 3 80 3 39 2 84 33 68 49 43 12 64 71 72 95 68 37 6 16 68 67 74 14 81 7 4 25 34 44 47 67 7 75 84 16 92 12 26 56 44 98 31 22 19 29 12 47 16 91 80 24 40 19 1 43 62 44 1 31 97 43 71 80 83 12 47 33 84 81 62 4 60 54 81 43 39 63 5 51 91 22 49 69 13 10 94 22 47 49 68 87 43 12 16 60 87 65 36 73 25 13 29 94 89 2 25 71 17 30 74 22 49 53 6 44 68 52 95 85 22 6 42 68 1 48 22 62 62 42 44 22 14 40 40 32 31 33 22 75 67 94 37 81 89 62 67 5 42 47 27 65 70 12 94 56 79 82 72 98 1 72 80 39 68 93 16 43 16 81 2 73 55 81 72 88 20 44 14 79 99 43 57 22\n 4 20 62 71 69 87 96 25 98 41 99 1 94 91 36 71 28 50 11 14 76 20 78 70 43 59 88 68 48 48 39 36 2 51 91 4 32 62 46 55 73 97 71 50 54 73 44 95 53 18 44 54 7 54 61 18 45 64 81 57 13 45 60 12 89 20 47 81 11 56 30 51 18 91 48 94 32 67 95 75 82 41 7 39 25 49 39 53 66 96 36 41 8 92 92 82 78 19 12 54 15 80 61 37 72 73 55 19 80 48 10 17 67 21 9 79 89 20 94 47 90 44 49 28 46 82 96 91 28 93 30 64 41 53 86 6 68 25 8 62 17 49 92 20 77 24 53 71 88 88 24 75 31 34 87 88 62 59 39 4 74 90 29 99 74 4 86 22 10 96 56 28 90 71 12 1 6 41 30 21 64 92 1 85 94 24 83 4 57 8 17 83 47 57 93 54 79 5 30 90\n 58 55 34 66 67 70 16 25 34 1 18 2 86 34 82 55 59 21 31 53 25 69 71 85 80 39 71 66 74 57 54 2 27 55 7 94 85 3 46 7 26 95 21 4 98 9 52 48 59 17 53 26 89 34 29 32 28 46 49 55 8 34 40 48 68 59 87 1 87 91 99 95 21 62 87 84 96 47 60 82 60 53 98 48 30 39 52 22 63 19 49 50 20 85 31 99 61 96 82 75 80 35 39 85 45 13 81 78 25 81 21 87 40 30 11 76 79 75 77 17 51 29 11 73 50 86 56 93 79 57 85 17 88 89 39 41 8 21 33 36 75 2 65 57 22 41 89 62 43 30 56 8 1 51 73 4 58 24 69 39 33 16 75 19 1 30 44 8 45 19 53 38 39 68 83 94 34 1 23 32 70 35 78 89 88 92 50 64 61 35 81 69 80 38 44 49 85 26 15 97\n 11 64 32 10 37 86 35 41 7 56 10 15 25 15 54 3 43 10 27 10 39 2 24 50 64 44 34 97 93 81 15 42 34 87 53 82 64 96 60 20 78 12 15 63 81 98 97 2 2 44 64 94 23 88 52 23 26 9 63 24 8 32 97 17 76 45 28 89 75 71 46 40 66 87 91 50 54 60 10 79 43 34 77 92 3 98 40 19 68 85 2 51 35 91 68 3 26 49 37 25 50 83 82 78 44 23 66 24 56 92 30 31 88 85 50 34 91 55 7 49 38 73 47 95 48 54 94 21 41 30 42 44 28 82 4 64 38 9 37 87 37 26 80 83 50 50 50 42 88 55 22 1 88 69 50 79 59 18 98 21 35 94 57 71 76 97 7 87 89 53 19 69 66 61 18 86 51 90 80 22 6 52 16 84 12 74 69 22 12 80 45 51 96 80 87 92 20 95 16 64\n 50 62 28 4 11 13 46 23 41 74 15 67 39 4 13 43 84 41 33 41 82 99 63 29 86 28 80 7 1 5 64 17 81 48 9 77 92 15 49 41 17 32 25 89 9 29 38 2 91 57 24 2 51 49 39 62 85 70 86 18 90 36 51 20 23 17 23 47 66 3 59 30 85 16 81 95 81 14 96 23 44 8 15 48 95 62 90 41 70 56 50 29 39 72 94 70 40 33 16 79 56 43 63 60 3 89 52 42 24 53 77 12 71 14 62 75 97 3 54 41 71 11 12 54 21 14 82 35 21 38 52 82 40 47 91 60 61 21 67 29 46 74 11 72 56 81 80 87 44 41 59 41 64 30 51 16 64 72 68 31 93 86 91 34 6 27 62 35 57 67 96 69 8 92 1 37 69 57 59 85 86 98 96 55 9 2 71 85 2 96 7 78 55 7 50 5 60 61 68 87\n 72 81 8 73 93 38 85 94 88 69 90 26 23 44 97 67 53 75 69 44 13 47 98 41 46 25 56 50 35 59 78 44 57 21 59 60 52 62 14 58 24 8 22 72 37 90 96 26 23 91 41 80 74 15 89 24 36 86 98 51 32 92 51 98 88 1 13 50 80 56 50 58 75 4 73 90 2 73 75 67 99 93 9 27 61 64 43 32 56 61 55 99 77 66 25 28 87 25 18 61 18 39 96 18 16 48 22 53 71 24 17 47 44 62 4 85 74 59 41 13 82 26 39 28 59 49 87 32 65 24 48 72 15 5 68 36 7 52 45 87 42 68 9 53 59 65 81 12 39 62 90 34 66 10 95 51 15 4 66 24 53 87 26 64 13 16 23 61 78 58 13 99 87 70 84 3 48 78 79 20 51 83 51 1 2 73 82 34 26 49 39 24 39 69 1 1 79 27 20 22\n 17 37 22 71 79 37 69 53 59 64 11 67 27 64 59 31 43 42 56 88 71 86 6 54 92 75 83 2 60 62 83 73 55 3 71 34 40 13 62 56 28 53 71 5 73 95 23 49 17 81 88 62 35 78 90 36 46 98 75 36 74 86 67 87 68 1 87 87 7 34 1 91 7 6 46 3 45 55 92 67 13 30 27 19 51 86 20 95 79 48 83 91 78 41 61 90 57 4 21 68 87 62 69 79 69 35 25 68 14 9 74 61 58 81 52 93 44 57 89 81 69 98 78 70 3 70 62 81 61 65 65 33 62 19 57 82 78 94 65 14 9 29 70 90 86 12 40 12 64 32 18 11 40 14 22 49 95 82 7 19 95 39 71 34 89 63 85 60 91 49 46 10 19 50 65 41 58 62 45 67 64 6 77 94 24 38 73 59 61 14 59 83 3 46 16 56 40 7 79 55\n 30 26 2 29 98 67 92 51 53 82 86 47 36 23 34 66 43 71 31 36 41 6 28 43 18 64 28 13 7 13 93 93 56 72 71 28 95 96 55 58 66 3 77 80 2 82 86 16 29 24 89 96 99 15 49 78 48 64 3 63 14 95 88 9 61 24 38 50 47 42 30 97 49 79 19 80 30 24 58 43 6 95 43 99 22 99 11 99 60 42 33 68 78 26 77 1 13 67 87 31 49 90 6 76 94 76 79 66 51 14 89 87 1 65 53 19 21 98 90 45 77 54 86 2 3 88 39 56 24 91 86 80 58 54 57 42 32 5 43 80 86 47 95 86 40 31 61 12 64 17 52 56 35 60 75 10 50 66 53 58 12 66 81 51 75 71 46 88 58 73 27 26 38 48 8 14 58 89 44 16 20 69 67 80 81 82 27 5 44 38 53 16 48 16 31 79 75 14 67 70\n 28 82 88 33 69 28 92 66 92 30 67 53 93 45 7 70 58 58 17 41 56 34 62 81 44 95 50 88 19 50 25 88 1 6 45 29 2 54 71 81 22 57 16 88 5 52 23 21 21 58 96 37 46 78 87 91 9 96 93 98 31 78 20 75 18 34 48 49 69 88 30 34 22 81 50 40 73 91 7 1 71 72 8 68 49 7 47 90 59 39 49 28 22 10 96 2 88 90 69 44 74 16 90 7 14 47 48 36 62 1 63 86 49 48 3 51 80 86 97 4 58 79 28 19 93 88 44 74 18 95 2 22 7 82 52 17 59 42 51 79 93 65 27 25 60 72 29 55 58 22 58 61 89 67 14 10 40 11 99 7 20 78 6 71 48 39 58 7 17 63 73 43 14 66 59 75 96 28 12 99 63 19 26 8 72 55 67 1 23 35 6 89 93 88 86 37 53 45 32 69\n 15 67 57 64 23 9 1 2 43 73 94 96 78 14 32 23 83 29 75 55 91 44 46 59 11 20 68 3 17 55 59 18 31 84 61 55 46 77 59 98 23 18 17 70 73 38 13 77 74 79 51 48 16 93 29 28 6 82 40 9 88 51 48 1 4 77 48 6 1 32 79 40 14 20 86 40 25 94 73 44 98 94 61 65 44 75 4 17 1 12 78 51 55 53 96 92 82 20 22 13 40 43 23 30 16 76 30 59 64 72 61 13 81 25 90 67 21 70 96 99 64 68 61 36 57 86 10 57 88 59 73 43 25 37 70 97 29 33 99 34 96 65 90 52 95 3 64 21 16 70 67 13 96 57 7 30 96 98 72 31 11 36 10 20 26 67 13 60 50 28 32 49 54 46 15 49 94 63 96 43 73 19 19 81 82 69 13 85 32 34 57 69 63 49 56 37 54 60 97 44\n 52 82 17 66 62 57 58 91 42 69 48 46 18 94 83 48 81 57 93 67 19 65 49 45 22 92 41 38 26 2 90 79 17 61 81 67 18 1 36 31 85 92 6 78 83 39 74 77 85 88 25 33 36 32 82 98 3 46 68 11 30 75 42 93 36 97 1 63 86 54 33 71 1 18 75 55 62 21 71 80 5 48 87 22 5 71 69 75 72 36 54 24 55 5 40 56 8 19 7 12 44 66 39 41 60 11 31 65 16 67 19 69 56 96 78 36 56 12 37 1 50 43 58 13 55 87 20 84 28 59 65 56 2 36 41 7 23 25 81 6 67 5 89 71 86 48 50 54 21 83 27 38 79 71 53 2 9 49 79 39 28 39 70 72 70 38 48 57 11 38 37 56 64 64 68 27 36 94 65 89 23 93 14 57 93 60 82 16 69 57 8 52 98 67 19 56 38 75 69 14\n 5 44 2 98 27 10 25 27 41 59 89 36 62 29 17 37 35 47 37 52 3 87 4 50 96 74 68 30 69 17 34 95 3 24 51 55 60 61 15 38 83 62 84 44 80 48 45 54 71 10 96 23 8 56 35 72 53 13 72 38 1 69 85 2 28 18 10 70 67 95 72 64 19 60 31 29 43 17 78 28 47 78 77 92 42 86 6 19 28 18 4 24 57 82 7 4 94 9 57 82 98 54 2 71 94 69 51 80 79 85 56 79 46 71 85 52 42 66 82 91 48 70 21 82 12 94 17 45 68 60 93 30 5 31 30 71 29 82 20 13 94 47 57 95 8 46 80 32 7 34 33 33 18 29 19 74 58 52 10 70 78 59 32 20 12 98 18 12 57 73 91 46 64 92 45 86 84 15 99 8 87 61 42 25 35 64 74 40 89 4 43 12 28 68 46 23 3 70 81 14\n 53 43 43 56 48 83 34 93 95 48 63 93 91 94 32 81 69 29 44 2 66 25 60 69 44 34 68 77 31 10 57 21 56 36 26 11 6 86 2 89 28 62 63 52 12 13 43 99 11 70 82 14 39 83 4 86 93 87 82 78 32 82 24 88 45 48 67 14 34 76 1 51 15 67 57 3 37 15 50 75 80 3 9 28 44 2 71 89 24 73 28 98 17 27 90 4 13 83 43 63 68 74 12 69 38 74 98 86 72 76 53 94 45 30 39 60 69 12 83 21 25 50 47 43 58 11 63 74 6 23 94 93 26 49 30 50 47 89 43 32 45 47 68 13 86 97 2 16 27 38 53 37 94 78 84 49 25 59 36 33 15 36 47 83 24 71 7 6 55 43 82 40 78 64 96 27 99 11 91 78 97 23 48 20 99 39 53 3 65 81 47 25 36 44 29 85 26 4 9 59\n 55 65 38 76 45 99 84 67 40 93 70 45 75 91 21 72 15 73 43 62 40 43 96 39 23 79 66 19 41 71 60 72 62 17 25 59 95 47 10 94 39 53 50 99 63 59 30 67 18 12 9 41 67 52 39 90 25 13 81 3 8 66 67 51 54 85 10 95 59 64 90 28 48 57 85 78 18 59 11 67 36 24 59 24 39 1 80 58 76 59 90 92 3 51 1 55 50 15 31 99 8 44 91 83 75 66 98 77 8 6 26 47 55 39 91 78 49 23 92 68 88 9 38 60 2 8 86 62 41 66 94 54 9 75 43 9 10 79 10 97 39 30 74 52 90 12 61 34 88 27 68 14 88 74 71 14 16 46 47 54 91 89 59 39 52 91 21 90 58 74 30 63 19 18 88 22 43 60 20 32 67 1 42 95 84 37 30 12 87 13 60 92 52 51 91 76 32 81 57 71\n 81 44 46 3 93 14 86 23 59 47 76 45 64 10 4 29 69 46 68 89 48 68 13 36 85 35 25 21 44 40 20 83 76 26 50 98 6 83 51 46 99 65 46 24 47 24 32 66 48 83 3 74 97 39 80 27 70 65 1 26 46 8 74 47 19 85 62 33 96 33 5 23 43 63 10 47 73 1 19 92 31 29 68 31 92 48 87 8 90 57 40 25 49 26 35 90 99 30 5 52 12 11 72 32 81 21 81 64 45 4 10 90 11 88 52 96 92 44 54 28 85 51 21 4 42 43 55 89 4 1 97 65 38 87 58 47 53 51 40 80 20 24 77 37 13 29 28 18 22 75 24 79 99 35 45 95 46 15 7 24 45 20 35 61 97 69 78 13 53 16 94 59 64 72 13 47 22 9 68 4 67 92 49 23 37 16 39 47 94 71 36 72 67 78 13 68 36 69 28 69\n 47 51 44 27 76 4 76 49 5 25 23 67 55 40 58 26 36 83 65 91 77 62 6 57 87 4 11 60 23 87 50 18 23 24 82 16 96 37 29 19 26 56 33 53 6 95 63 84 13 6 19 16 80 37 20 62 81 52 14 67 19 86 1 53 21 33 68 28 25 69 71 60 69 99 53 77 27 29 83 22 10 42 64 80 73 91 38 60 53 38 19 14 35 10 44 97 17 50 22 19 70 88 31 7 81 58 2 89 1 80 52 15 25 11 97 90 62 69 34 66 54 84 62 71 70 60 54 52 71 9 99 41 30 23 60 1 67 55 64 21 16 94 11 90 48 85 34 7 79 95 50 78 39 79 69 27 42 15 51 44 71 32 66 49 8 7 44 1 15 6 51 91 33 77 69 28 8 8 48 7 55 51 89 61 82 39 89 47 24 79 86 60 67 10 61 60 68 72 9 47\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 1019331795 11311 11132\nprocessing times :\n 67 70 39 25 43 43 10 41 70 39 4 89 83 48 41 88 39 96 51 95 73 65 58 31 37 69 18 62 14 27 17 93 14 95 68 90 99 40 11 2 69 92 50 55 28 54 98 42 93 48 79 55 29 98 24 48 33 86 28 71 46 91 5 58 7 99 28 60 15 22 70 28 85 44 71 43 40 2 79 16 60 34 42 94 32 19 69 49 82 53 2 94 85 24 13 21 53 62 54 13 87 15 18 55 17 45 3 78 91 52 32 4 51 75 75 68 54 51 29 96 19 55 63 73 75 72 71 28 45 76 79 81 13 9 48 85 68 9 60 77 71 3 75 78 64 55 20 19 53 45 71 99 75 59 15 76 33 36 44 41 37 2 43 50 57 23 60 59 29 5 27 88 67 17 40 3 64 92 27 20 82 40 96 82 7 78 91 82 79 79 28 41 9 91 38 50 91 80 24 68\n 88 73 23 94 9 64 60 65 53 93 69 75 50 91 25 67 19 21 37 27 16 31 33 52 70 27 4 46 52 12 30 28 12 14 65 69 21 15 92 74 77 11 95 2 4 50 38 88 77 54 72 59 76 96 83 21 87 56 75 50 85 22 42 33 65 94 92 55 20 5 81 68 29 22 11 5 50 98 28 23 28 77 54 72 48 39 93 94 91 60 73 52 15 60 75 87 3 3 22 83 26 67 79 73 93 76 40 94 17 1 78 3 39 47 41 7 81 64 37 39 88 70 94 23 29 68 95 31 76 35 68 28 48 33 90 34 28 60 33 93 17 84 84 17 86 97 70 84 83 3 3 58 67 45 55 20 43 33 77 91 81 13 13 98 49 95 11 91 3 63 7 9 25 74 17 52 79 52 44 42 93 99 60 48 61 41 42 53 12 86 3 33 2 46 75 25 31 20 81 6\n 65 96 3 43 89 20 11 36 52 72 8 30 30 20 82 92 66 97 78 53 40 48 20 14 42 19 63 79 26 10 51 74 36 45 30 94 67 1 72 38 76 8 70 31 13 44 77 3 64 46 74 81 8 86 29 42 62 42 73 95 8 26 74 37 88 21 31 54 9 46 9 5 30 59 41 4 32 58 84 79 45 35 42 4 29 77 36 52 33 24 18 24 90 46 10 32 18 45 53 23 53 15 5 42 34 52 26 57 28 18 71 5 69 18 94 66 84 23 66 15 93 34 71 61 19 58 21 54 73 49 3 38 85 4 49 84 30 70 60 9 11 95 99 94 63 81 17 1 72 24 52 67 94 79 91 58 76 19 13 33 98 61 13 41 93 43 43 47 13 69 35 16 11 10 39 11 91 24 74 94 3 73 61 84 34 97 46 76 89 15 55 92 34 30 9 79 41 48 85 77\n 83 25 95 10 36 23 96 7 21 16 32 45 85 81 81 3 43 33 67 56 6 42 1 98 19 44 10 63 98 76 29 59 65 57 74 74 22 71 36 63 72 61 34 78 61 56 44 31 63 22 74 88 25 89 75 26 91 21 81 3 76 10 95 93 1 85 63 91 56 2 61 72 50 89 43 85 84 92 54 66 74 38 26 72 4 1 47 79 24 91 71 50 60 71 75 20 43 7 11 11 15 45 16 52 38 36 19 70 42 77 78 4 57 70 71 95 69 68 97 29 50 21 1 63 41 98 28 7 17 36 93 26 65 63 71 71 74 86 81 28 12 62 98 48 71 35 27 36 47 99 10 30 3 46 21 37 41 2 74 17 91 30 29 95 23 87 67 15 80 69 29 65 71 23 8 76 5 7 81 1 60 46 84 65 26 3 5 2 79 80 92 24 1 57 75 28 85 10 15 64\n 64 51 9 16 78 85 57 18 28 25 8 50 21 44 85 90 89 35 80 94 48 95 70 34 77 16 18 68 18 92 36 2 14 58 29 79 22 7 29 45 45 41 10 55 83 19 39 34 79 39 22 86 69 15 16 31 85 27 10 89 58 96 71 89 25 18 3 29 74 10 59 55 51 67 48 47 54 72 15 10 59 83 4 64 69 40 34 78 78 56 63 17 3 29 75 2 78 44 51 10 62 7 31 84 43 49 6 26 88 24 4 39 80 87 17 12 6 12 7 93 35 55 40 49 34 84 45 75 43 94 61 50 17 14 19 85 8 91 72 59 73 27 72 96 64 75 78 54 70 26 40 59 5 45 90 27 92 2 30 5 54 3 36 21 41 90 43 6 88 28 4 17 51 33 71 6 69 81 70 14 99 19 76 91 27 29 22 94 86 48 99 80 96 42 31 9 87 71 61 29\n 33 73 40 75 1 16 69 73 98 40 12 96 8 42 52 87 84 67 54 33 36 37 74 70 42 1 20 22 57 19 21 49 97 88 44 17 4 56 8 73 63 16 53 5 32 81 29 30 26 35 10 38 88 96 70 89 56 83 99 99 82 67 32 45 97 43 87 22 57 71 20 63 52 39 42 26 22 59 85 93 65 47 1 15 20 53 32 35 20 80 87 22 22 91 8 88 31 36 11 36 46 23 76 3 37 86 39 86 99 26 4 27 49 69 69 38 45 2 71 76 59 94 27 97 23 77 59 9 92 21 66 92 7 35 24 56 87 52 86 72 97 47 51 6 88 5 58 98 13 3 63 93 51 55 13 81 71 21 45 79 91 58 28 96 44 66 60 18 44 79 21 69 31 88 61 88 48 34 47 45 19 81 72 35 40 18 15 28 92 18 98 72 13 14 78 51 90 63 30 1\n 42 9 28 75 14 55 37 66 25 65 79 6 27 45 87 85 50 87 24 32 29 33 84 43 22 81 21 14 4 29 41 13 75 22 9 42 84 44 28 19 83 8 11 91 10 22 83 55 93 14 53 20 34 72 11 43 42 28 57 75 29 64 69 78 88 87 50 21 75 41 11 49 53 49 21 51 7 37 88 51 79 84 37 73 55 26 16 65 46 79 34 70 61 24 54 37 85 33 71 3 99 77 21 29 28 71 2 46 71 70 93 62 99 39 94 29 94 44 72 97 40 6 48 8 22 3 44 39 61 25 61 16 89 15 69 88 49 94 54 3 41 41 19 36 6 96 42 4 41 41 42 51 77 24 45 59 68 56 28 41 23 29 12 71 82 52 33 35 61 85 40 25 50 91 84 37 95 88 97 78 96 53 74 46 20 49 39 26 82 21 41 36 48 11 82 33 90 49 13 93\n 43 86 97 34 1 17 35 51 57 17 18 36 26 95 58 75 77 9 26 27 13 56 63 69 66 3 54 82 38 61 16 3 74 33 57 86 22 61 16 32 5 96 71 59 46 88 59 15 12 59 72 64 25 21 41 36 21 52 67 92 97 54 2 86 60 21 34 21 98 52 83 40 6 6 38 61 18 28 98 16 17 38 26 57 13 3 54 17 32 89 38 33 54 16 16 98 7 25 4 54 1 35 9 51 4 64 86 40 98 36 44 72 46 14 58 36 41 73 19 78 2 94 13 57 97 16 30 11 73 31 42 53 11 8 16 69 23 22 77 11 25 26 92 54 78 13 26 59 53 22 76 64 6 84 7 9 91 7 94 47 31 30 77 59 30 35 73 4 47 95 6 83 7 74 59 60 29 25 44 92 95 87 80 18 11 28 76 88 48 58 45 21 83 58 77 82 26 87 93 39\n 87 13 92 47 83 9 97 53 44 94 84 95 6 59 58 16 25 19 16 23 29 69 59 94 73 9 45 20 16 56 14 22 35 58 86 36 23 74 3 56 44 63 35 34 62 78 1 43 75 7 11 16 67 69 44 64 33 95 69 30 3 41 15 36 50 45 50 14 86 15 83 77 41 58 26 94 77 95 47 12 97 74 24 13 71 19 85 49 99 45 72 34 5 2 1 86 3 35 96 32 39 84 33 38 17 35 46 19 75 32 41 25 75 28 82 78 72 51 69 70 21 99 91 63 73 92 82 81 73 98 48 10 90 60 80 29 87 35 6 94 33 4 32 68 57 47 72 93 66 44 61 76 80 11 86 85 47 99 22 50 12 4 36 69 49 78 54 82 95 59 90 75 5 97 28 52 16 24 67 54 39 48 23 62 51 51 35 14 32 63 12 51 44 71 17 73 17 41 6 49\n 4 10 2 51 15 27 36 31 8 48 34 35 95 19 47 31 18 42 67 97 91 80 70 26 32 22 23 58 82 28 13 92 86 64 69 10 72 45 84 34 4 70 87 69 43 77 66 90 92 86 50 83 29 1 12 12 98 31 72 21 87 10 59 96 58 28 50 3 86 78 69 52 46 93 75 13 61 76 63 99 57 58 37 99 81 16 44 56 68 64 52 78 83 44 8 22 73 12 11 33 39 68 36 31 89 42 60 71 11 63 23 86 72 75 11 67 22 47 41 22 77 15 64 42 73 10 53 6 9 57 49 20 88 82 70 63 37 22 50 92 9 13 75 1 3 77 32 45 56 92 35 71 95 15 70 58 69 82 2 21 32 10 85 85 79 18 61 15 49 84 48 59 5 41 1 24 19 85 28 23 43 16 24 49 72 45 61 70 68 82 91 96 10 42 69 21 85 93 1 98\n 14 87 47 75 12 29 10 11 88 98 45 19 49 27 27 97 89 86 65 79 19 76 85 27 98 87 46 81 46 32 54 49 69 66 96 13 93 62 50 75 55 58 5 40 39 5 39 60 87 52 25 11 40 62 15 92 5 33 30 76 15 36 23 7 84 49 67 98 78 56 36 4 99 42 81 76 18 44 68 72 67 71 57 86 78 32 95 55 14 55 50 79 20 47 62 86 70 69 26 80 23 88 93 98 52 16 21 45 79 49 99 5 51 41 27 32 35 18 70 35 21 25 91 69 42 22 54 50 70 35 46 99 47 11 42 39 12 73 43 15 34 95 2 39 46 27 46 28 65 75 99 62 66 91 93 36 14 53 79 34 53 42 29 67 52 38 87 86 1 99 66 96 99 37 24 46 54 76 84 95 35 93 66 95 64 50 36 82 70 46 99 19 57 29 26 13 17 95 69 56\n 7 20 58 23 73 96 67 82 79 31 44 37 80 38 80 7 87 3 34 89 95 9 24 36 19 99 58 32 74 49 17 91 29 3 56 8 21 36 37 15 1 65 52 77 3 83 17 98 97 13 33 70 11 44 10 43 41 49 25 64 63 60 87 18 39 80 10 18 25 66 28 47 86 15 2 64 96 79 47 14 47 85 9 56 74 2 6 80 14 60 69 25 30 50 79 1 3 10 82 16 27 25 67 31 29 74 96 44 14 47 64 41 74 16 45 96 89 83 37 49 71 27 54 25 94 92 21 2 57 43 46 80 77 32 61 21 75 16 73 84 85 54 73 6 39 65 72 32 40 94 78 41 83 27 24 18 60 13 15 68 3 49 81 45 56 10 78 22 3 46 44 1 28 42 24 35 19 13 26 61 64 26 25 89 53 90 85 97 41 98 29 1 50 50 29 22 47 48 17 62\n 13 51 91 85 10 42 59 30 7 28 40 88 92 1 22 3 42 63 33 99 79 55 52 29 2 42 97 13 88 18 7 53 8 2 85 37 23 72 3 23 33 94 48 10 45 20 72 85 21 7 85 6 30 42 72 57 5 82 54 87 70 92 14 25 87 79 32 88 9 6 60 49 44 83 63 58 39 34 23 74 39 92 21 23 4 87 63 99 87 51 91 22 54 37 3 99 96 67 78 24 6 52 55 69 7 74 20 61 77 7 37 26 8 29 29 73 60 72 93 75 82 16 65 46 4 88 90 7 51 51 11 42 56 73 65 72 27 49 59 44 40 90 51 50 1 59 99 92 23 61 69 31 52 64 72 21 7 84 19 6 67 3 75 12 23 39 67 59 33 11 24 33 6 61 49 61 59 27 69 15 1 53 65 29 25 35 81 26 35 3 81 17 4 73 25 77 66 12 80 75\n 29 13 9 24 19 38 68 56 67 6 74 94 27 59 24 85 28 81 82 23 90 7 50 37 40 94 40 96 47 99 78 71 7 35 67 93 1 50 18 88 91 88 72 99 4 27 22 36 30 1 65 57 90 66 17 69 61 77 43 7 34 89 75 81 81 32 34 77 59 32 52 63 7 75 37 3 65 6 27 22 6 38 16 58 52 8 48 93 76 20 91 41 92 97 78 13 94 17 71 83 36 55 52 68 54 44 84 34 81 75 35 34 34 46 4 32 69 15 41 33 14 63 3 64 52 2 29 30 49 66 10 63 39 40 52 63 15 16 48 97 56 18 81 26 31 86 39 28 21 41 65 2 11 35 96 13 63 6 14 96 64 57 80 25 41 64 33 28 76 34 33 83 79 20 29 25 71 1 48 71 6 92 43 32 67 3 53 60 33 62 47 64 26 74 27 21 94 82 95 38\n 74 49 50 73 88 25 35 88 73 55 72 86 17 96 78 20 9 54 31 33 22 55 16 16 67 8 18 76 53 42 43 24 18 79 97 31 52 52 73 27 4 67 70 28 2 92 50 98 11 79 95 8 73 37 32 18 95 80 11 3 6 55 69 83 89 20 55 31 65 66 26 79 57 92 89 9 4 87 90 67 80 8 46 96 19 96 91 58 89 6 50 11 58 53 1 12 58 8 20 89 69 20 47 91 57 24 46 56 45 11 75 8 82 70 96 89 9 68 73 21 12 52 83 2 97 32 37 47 47 97 69 10 21 92 2 60 94 73 2 40 51 93 58 8 19 38 76 42 14 44 41 98 34 12 26 17 70 72 80 16 94 40 56 20 26 84 77 86 54 79 49 9 69 33 52 94 45 56 93 4 19 96 15 61 48 88 87 76 81 48 36 60 52 28 58 47 11 23 11 92\n 7 28 94 87 86 11 50 35 19 96 71 55 15 79 51 54 26 80 57 34 93 12 76 28 79 42 50 77 41 32 98 38 5 69 44 54 46 54 11 78 39 23 30 70 21 39 91 40 94 6 77 17 48 17 86 74 45 93 80 1 40 59 97 98 50 34 82 5 9 17 45 23 36 15 83 84 91 64 41 98 62 62 94 48 21 73 75 39 44 46 31 48 19 55 36 86 28 78 57 74 26 20 98 77 16 57 60 34 94 64 84 45 27 43 94 50 42 82 61 68 10 22 5 77 46 43 97 17 11 17 2 66 41 63 58 41 18 16 91 48 79 46 36 8 48 35 82 60 43 16 78 33 20 5 33 32 61 46 90 55 95 54 45 72 86 36 38 37 17 60 50 85 39 89 1 92 54 85 63 40 82 42 55 43 28 19 30 77 28 58 10 89 54 66 16 12 70 6 53 45\n 10 24 67 32 60 45 75 53 25 88 41 73 90 92 59 72 89 12 43 30 33 51 2 11 45 66 29 28 6 84 26 88 86 18 88 70 33 26 54 34 88 72 94 91 80 40 27 41 28 77 43 51 82 5 27 91 73 15 66 87 99 18 56 4 51 28 45 81 4 13 50 89 41 35 83 25 98 96 46 65 6 4 20 54 26 29 75 17 88 52 82 23 33 70 67 80 33 58 27 25 51 90 2 94 23 50 34 19 88 83 55 47 6 72 18 43 14 79 73 61 96 64 87 24 50 94 43 83 15 43 23 28 12 82 85 23 53 46 14 31 14 80 2 78 93 68 88 5 75 60 21 46 13 21 68 18 21 40 4 23 89 3 25 61 44 18 44 9 24 71 26 26 99 54 83 73 21 81 91 70 9 49 34 8 77 26 84 97 67 59 12 83 90 73 54 61 98 53 54 75\n 67 13 26 41 7 76 52 73 69 59 31 6 99 32 15 36 41 62 31 52 79 74 24 40 98 42 21 70 64 84 92 24 78 18 13 62 38 28 56 65 46 1 98 67 61 37 36 54 17 68 41 25 30 68 66 29 27 87 95 9 14 3 23 52 24 21 42 67 94 15 53 65 98 10 52 10 32 32 50 85 10 33 38 21 92 70 70 85 72 96 39 3 14 68 83 81 16 93 64 87 36 66 83 27 45 45 8 38 72 92 95 73 15 16 8 58 61 55 53 21 83 54 96 58 87 75 7 77 83 17 83 85 46 65 60 77 20 45 9 5 2 35 43 3 51 92 37 33 4 80 82 85 31 77 63 58 38 92 34 88 79 94 26 15 7 94 69 48 75 78 90 24 24 4 20 5 44 31 98 59 11 26 63 77 12 67 77 17 74 10 84 35 51 20 20 60 88 97 5 27\n 80 77 33 95 27 14 80 73 58 8 34 99 82 93 75 21 43 1 87 91 95 66 84 56 32 85 22 77 97 18 39 5 20 26 52 41 29 21 12 77 87 94 39 77 64 24 58 98 42 52 9 36 78 42 24 16 93 16 27 15 20 94 32 85 77 97 16 30 87 34 40 27 73 47 57 64 76 90 48 69 16 62 54 22 64 62 14 96 22 67 92 14 54 93 11 81 92 48 71 43 63 27 98 49 76 46 27 96 36 62 54 3 27 62 58 75 8 82 9 84 82 69 94 35 90 94 35 73 16 73 92 54 62 2 44 13 53 51 47 56 4 45 89 67 76 73 41 32 79 83 73 85 5 10 98 82 34 15 69 54 94 13 70 32 78 47 22 31 41 57 97 40 90 76 31 65 42 66 22 70 9 73 81 68 65 33 5 55 79 42 3 78 11 20 51 4 9 17 49 29\n 44 62 60 84 38 70 7 41 58 23 91 78 64 38 79 45 30 20 16 80 93 20 4 52 73 9 50 78 41 90 65 18 87 97 10 75 94 88 30 29 12 54 28 33 75 60 72 66 11 2 44 73 52 30 62 12 87 27 15 57 65 38 92 5 5 1 34 50 66 47 8 88 82 75 46 99 8 45 95 49 12 90 93 67 43 22 8 9 54 58 52 59 31 87 72 85 33 36 79 73 64 94 91 28 77 24 96 55 92 31 61 9 65 23 14 13 31 47 69 41 6 88 93 2 22 5 6 23 28 54 58 22 86 50 8 55 1 37 53 20 31 67 99 21 45 81 86 2 64 71 97 50 70 95 64 67 46 41 63 47 27 54 18 77 1 59 73 52 75 34 54 60 92 33 78 20 70 11 95 88 17 64 59 64 16 87 3 87 9 94 23 99 38 19 37 73 47 58 46 54\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 2056065863 11282 11085\nprocessing times :\n 53 89 86 31 77 40 44 94 90 73 91 29 48 27 79 14 57 87 85 77 37 52 48 50 97 82 48 55 65 69 94 25 91 34 27 42 6 58 35 31 52 17 58 1 66 65 77 81 17 38 95 69 18 85 72 72 96 49 16 39 1 98 78 50 52 12 92 81 51 97 96 9 83 47 19 89 83 20 66 11 85 18 91 98 25 80 38 61 50 31 97 2 87 55 20 47 13 13 78 76 22 8 46 48 34 98 57 3 86 15 40 7 55 33 45 58 14 97 55 74 6 2 13 94 6 78 27 87 88 24 24 89 99 1 75 88 24 77 12 1 55 27 43 49 3 69 76 43 63 45 36 2 99 50 27 18 24 13 89 33 67 34 33 80 79 83 62 96 20 54 17 51 1 80 35 58 60 95 78 5 24 82 47 91 69 71 73 42 47 47 24 10 90 94 24 33 91 20 65 42\n 70 26 92 58 33 83 66 81 51 56 79 44 88 19 37 62 11 62 28 75 71 77 36 61 39 87 44 89 24 53 19 59 17 65 34 71 81 72 50 87 86 49 59 11 32 64 53 86 54 41 53 77 43 98 19 56 69 56 77 9 71 45 92 86 33 86 83 80 52 22 11 21 12 86 76 35 12 23 64 21 46 62 86 22 58 4 94 8 79 67 39 9 67 37 43 14 2 21 56 92 1 96 57 62 69 75 14 59 31 62 46 93 24 53 32 79 31 94 93 17 73 71 62 42 74 61 48 14 54 60 70 29 59 79 81 42 44 92 2 72 53 20 73 99 11 49 25 95 14 23 5 6 26 37 89 90 17 68 79 39 98 13 87 9 21 48 1 95 60 4 43 89 94 7 76 9 12 54 15 9 40 53 86 29 67 74 27 50 29 51 73 2 79 73 3 55 50 17 5 21\n 30 64 2 48 61 76 51 61 98 98 28 27 93 70 82 45 63 45 60 90 95 12 53 87 34 70 71 69 46 80 1 46 8 10 25 69 6 8 65 38 69 67 77 34 15 29 16 86 97 88 12 90 8 7 48 37 37 53 40 65 58 21 67 53 88 86 14 88 34 38 22 53 45 27 14 90 96 76 85 41 24 5 28 33 49 87 99 37 37 27 52 64 46 93 41 86 24 7 49 28 7 62 87 9 78 32 42 23 52 18 90 89 99 9 24 75 26 73 87 74 1 40 29 84 69 89 28 22 74 24 57 77 40 8 84 34 11 57 99 6 52 18 5 87 4 89 11 98 83 30 94 15 17 26 75 28 16 37 21 47 24 98 6 93 56 70 35 1 60 35 25 7 45 50 93 45 61 75 99 2 30 97 82 89 72 69 36 48 87 30 18 73 64 21 68 18 22 39 64 51\n 19 27 33 2 4 77 22 64 19 93 25 85 90 88 17 88 74 78 17 10 98 93 53 73 19 76 78 64 36 99 91 59 40 39 16 24 84 82 26 67 47 25 83 3 92 30 64 10 56 74 67 52 80 56 63 90 95 3 60 17 49 72 68 24 95 44 96 22 64 30 25 66 96 47 99 15 94 28 95 22 56 43 93 29 37 48 2 7 11 72 96 74 79 84 93 28 72 1 90 84 89 82 65 63 23 76 98 35 64 45 65 99 89 52 21 54 3 70 34 45 1 36 13 54 32 26 62 29 56 65 55 52 93 82 76 79 18 11 6 4 62 12 41 7 40 75 35 77 25 82 72 35 6 2 48 99 2 17 54 8 99 76 62 47 30 88 24 22 98 51 62 90 57 97 13 11 62 5 76 81 35 18 83 72 27 61 74 52 95 2 2 9 81 55 45 32 36 3 91 37\n 14 92 54 38 77 96 55 42 74 65 34 64 3 94 94 9 56 20 76 98 47 89 13 83 64 36 36 42 89 86 92 53 40 10 56 54 80 10 27 20 99 4 67 35 97 82 53 94 59 74 80 95 2 37 53 34 89 70 10 6 70 58 99 12 83 37 9 99 90 91 84 21 20 98 12 49 47 60 63 61 25 90 39 62 76 96 52 2 50 90 51 50 15 88 92 6 91 8 34 5 67 51 13 76 89 91 31 40 14 86 40 68 59 43 54 74 9 85 18 37 2 25 39 76 11 8 63 48 72 65 60 86 20 2 26 74 65 59 58 74 29 29 73 56 93 56 5 58 38 91 68 37 98 50 92 74 4 71 14 9 15 63 6 3 73 81 17 78 38 36 61 5 39 50 55 4 58 34 53 22 9 87 90 50 5 64 26 37 98 48 35 88 21 26 33 61 84 79 77 37\n 64 68 18 1 96 71 90 34 73 97 62 52 78 93 81 28 70 48 41 67 61 21 8 74 66 11 60 36 54 77 77 86 77 76 56 24 15 26 55 86 13 69 77 48 15 62 79 17 69 24 46 89 87 15 51 17 93 76 4 74 71 74 53 76 28 30 20 19 14 78 51 23 64 24 41 88 73 12 26 85 10 39 72 12 21 32 14 22 10 40 59 46 42 2 38 80 19 77 27 27 95 29 86 41 69 43 19 74 52 22 41 34 89 49 46 64 21 7 31 91 55 10 82 70 57 1 89 67 82 62 23 79 32 64 25 86 32 47 98 65 29 67 74 28 2 81 52 12 76 76 24 54 32 45 89 37 30 17 65 40 8 77 36 25 62 78 64 63 86 22 65 34 40 20 45 82 73 48 42 62 43 44 26 35 98 48 91 76 41 8 2 39 94 75 15 6 58 17 89 30\n 25 59 62 47 13 37 15 80 39 23 18 70 47 91 42 63 50 97 47 43 33 1 24 20 93 5 75 81 72 87 94 1 27 70 54 80 69 20 51 24 86 24 22 87 5 60 25 3 26 75 78 5 84 43 42 35 76 55 66 15 10 47 25 78 52 73 46 77 68 7 63 36 48 38 73 34 59 75 30 26 18 92 16 4 69 17 66 67 98 12 33 25 4 19 77 82 34 6 30 77 31 54 5 86 41 81 29 80 67 77 93 44 10 51 25 91 66 36 2 68 3 69 11 60 98 75 65 34 41 58 86 77 18 6 9 83 4 19 8 45 47 8 83 85 77 83 94 11 72 2 72 8 77 12 73 30 28 25 27 2 57 75 17 97 5 13 71 76 21 27 21 85 71 73 47 88 10 59 56 35 25 51 92 61 8 12 19 41 37 67 36 95 1 16 9 93 68 46 65 85\n 76 8 80 55 56 62 49 24 6 70 1 57 11 57 23 71 28 7 47 84 71 15 84 8 96 64 29 55 43 27 44 31 90 19 62 93 47 63 14 80 51 40 66 41 87 79 97 60 61 64 14 4 46 30 94 67 30 2 52 25 93 3 88 51 43 70 19 5 28 20 14 90 98 28 60 50 56 34 35 43 95 62 10 21 32 2 11 59 62 55 55 63 38 3 98 12 45 1 25 85 1 97 39 79 13 23 26 78 2 39 94 21 67 81 87 52 3 17 26 99 54 33 75 99 80 77 13 91 42 98 89 97 74 5 65 75 96 59 81 53 67 76 46 56 41 55 95 60 51 20 5 36 85 95 53 83 47 52 72 62 78 95 31 65 74 89 78 74 40 99 48 87 10 34 33 39 31 51 12 9 26 23 57 7 63 93 1 61 88 1 14 21 77 87 38 59 68 1 74 24\n 13 53 11 60 52 31 84 79 12 27 27 33 29 22 44 28 3 31 16 35 10 76 64 83 92 40 18 80 60 6 32 49 50 80 40 88 23 66 99 92 42 84 76 13 57 10 46 49 37 78 18 63 34 8 98 73 49 34 77 65 54 79 48 14 93 29 67 16 42 86 33 39 77 19 11 33 43 32 93 85 25 55 71 65 22 74 54 20 88 93 83 12 87 88 18 73 37 72 34 80 28 72 71 21 73 59 44 86 93 83 70 77 8 70 39 53 65 47 40 55 54 53 84 42 11 95 30 20 40 57 93 34 94 7 48 43 33 85 19 10 32 25 43 59 4 3 76 13 63 8 34 28 36 81 66 73 35 37 63 20 80 53 61 96 75 71 65 14 71 5 28 16 29 80 37 47 25 25 46 72 63 30 43 57 28 64 59 99 63 53 61 95 33 13 63 86 36 69 1 82\n 74 45 42 26 81 87 64 96 32 98 70 10 58 64 84 96 12 85 71 73 7 70 23 61 58 96 14 34 60 52 59 62 83 68 42 1 20 22 2 77 18 52 36 96 56 30 30 89 27 27 58 40 23 25 40 43 96 51 65 54 46 57 33 25 67 53 12 94 69 54 50 84 83 70 39 5 49 10 3 58 45 77 86 75 63 61 19 75 8 16 51 90 98 51 77 16 90 39 37 19 18 74 13 10 99 58 68 25 33 11 11 85 50 84 52 41 81 33 15 47 56 87 74 83 81 48 40 19 56 56 12 83 20 3 75 85 23 95 61 35 35 46 85 27 17 84 77 78 57 59 4 99 77 63 63 43 99 47 18 6 92 56 41 37 53 84 67 48 57 66 44 45 93 32 31 61 82 27 51 73 55 6 92 27 66 12 20 94 77 40 82 16 17 25 43 11 44 83 33 20\n 62 15 64 54 63 98 26 13 41 1 58 79 74 39 6 8 97 35 30 1 34 16 20 30 97 86 2 66 4 27 12 11 62 11 76 59 49 76 19 85 22 54 29 76 23 96 45 4 3 70 93 63 8 43 90 28 41 92 6 32 21 34 66 68 33 17 13 67 99 65 20 38 21 49 10 8 53 91 78 33 19 24 47 27 72 26 74 53 67 43 61 10 7 31 10 15 66 46 3 85 5 70 1 87 85 11 51 28 92 52 78 53 25 96 82 68 67 59 35 11 29 2 72 44 92 36 27 54 59 12 33 37 4 10 12 51 62 65 73 90 17 44 98 22 29 46 40 19 49 6 42 9 69 56 12 19 3 7 98 19 68 91 45 58 3 93 51 39 44 50 19 62 61 84 95 13 20 43 29 31 39 35 49 66 39 74 80 87 12 19 53 35 69 35 5 96 13 68 15 30\n 76 78 57 42 61 2 98 80 75 26 25 40 44 59 71 89 38 84 31 88 38 62 53 95 78 45 46 83 15 30 50 34 2 2 3 60 72 4 39 9 87 8 58 6 38 70 37 38 34 28 26 10 19 2 92 77 37 93 13 17 42 87 74 2 42 31 44 16 81 78 82 85 72 84 34 3 3 57 65 21 54 27 18 90 80 82 74 93 63 98 70 39 34 38 13 26 38 47 48 80 79 5 91 16 7 97 63 91 30 71 77 15 54 99 82 58 37 64 6 88 38 38 8 41 70 10 54 84 19 17 27 97 80 35 24 38 59 10 47 40 1 1 75 44 90 57 97 30 56 47 72 16 51 29 74 39 49 96 39 47 99 3 62 14 82 9 51 23 91 58 9 97 88 96 33 15 93 61 41 63 29 5 35 4 36 73 52 58 67 12 28 11 68 85 81 78 43 80 49 58\n 13 33 60 92 13 50 16 41 26 51 43 93 65 90 19 58 66 88 58 22 45 3 22 27 33 68 50 75 76 53 59 60 25 97 61 97 29 31 28 58 95 66 7 16 25 81 35 83 99 53 53 3 18 75 22 88 99 33 75 22 50 30 71 57 44 26 65 52 11 85 22 98 31 45 74 15 9 23 68 48 32 1 72 50 36 7 75 73 77 69 22 23 67 43 30 56 78 20 4 88 7 38 39 50 87 70 21 87 22 67 51 16 76 84 32 34 33 31 39 23 10 87 79 91 47 83 21 19 23 78 80 50 40 4 36 11 97 46 45 99 25 36 96 69 10 6 59 37 55 18 63 67 82 91 81 86 61 71 38 98 43 20 13 49 51 63 20 22 3 72 78 42 83 63 5 79 83 40 61 8 90 38 20 71 78 9 31 40 82 47 14 5 30 98 13 75 80 34 83 80\n 1 34 84 76 86 78 80 64 11 68 39 9 66 34 30 60 90 19 46 38 94 18 63 41 26 82 90 90 10 78 34 16 17 22 78 81 38 33 8 20 73 29 80 44 42 97 80 39 25 6 33 58 85 26 98 93 13 94 39 91 33 47 11 19 99 95 99 41 10 62 81 35 13 99 57 25 89 5 26 42 10 3 89 28 97 57 48 30 9 28 72 68 27 77 3 67 68 97 2 96 22 62 82 32 47 61 25 47 79 40 65 93 93 41 94 53 98 59 63 96 11 27 54 57 97 27 11 25 33 72 89 8 66 97 59 57 96 97 56 73 51 61 81 69 88 25 57 14 71 15 95 26 59 66 76 22 72 93 28 90 21 52 35 17 85 74 65 45 91 34 88 36 58 78 16 18 15 6 52 63 57 93 27 16 3 81 76 54 79 76 66 98 74 29 91 9 73 28 78 12\n 15 68 12 16 86 26 93 98 16 15 23 43 39 28 79 24 15 71 88 78 12 56 34 85 27 29 32 23 34 61 14 61 18 50 58 99 97 92 58 53 87 38 17 89 65 22 75 80 64 53 9 65 27 8 7 65 11 61 64 68 8 54 22 80 48 97 5 51 80 62 32 46 38 39 50 60 83 80 5 70 94 71 21 39 65 1 35 80 49 35 44 40 12 48 25 41 37 87 38 25 60 11 52 37 74 27 87 35 53 27 76 69 54 82 52 35 76 26 28 59 94 86 63 47 19 37 83 70 28 62 69 41 92 11 66 92 51 67 31 55 81 15 35 30 80 75 1 13 47 7 34 60 90 46 21 65 84 10 67 66 49 14 26 22 61 60 9 66 93 9 85 80 51 99 77 77 82 57 43 88 77 59 18 7 79 45 70 59 23 24 52 87 35 22 26 90 38 94 66 69\n 1 82 93 97 21 48 61 78 1 60 39 54 46 55 2 86 85 30 74 15 83 42 78 44 19 8 13 33 82 52 65 68 33 74 10 12 97 24 38 20 15 78 22 48 56 77 71 50 80 72 58 71 64 66 23 58 55 4 39 96 11 27 68 78 95 84 38 15 56 58 22 85 92 62 6 4 25 10 27 81 5 26 25 66 63 43 9 54 92 7 63 55 4 68 71 67 39 3 6 1 95 24 75 33 52 24 23 71 43 35 9 62 54 85 56 3 52 99 17 68 14 15 21 79 16 34 42 84 39 97 14 91 95 30 81 4 83 9 84 86 30 94 55 77 46 70 88 73 31 4 32 95 18 75 19 4 82 16 74 10 82 20 58 89 53 94 92 81 31 52 88 25 92 43 77 43 46 19 71 16 96 87 62 8 12 98 39 79 28 57 90 83 78 49 29 78 28 93 59 98\n 51 17 4 99 47 63 67 47 51 69 17 7 40 92 28 30 6 40 42 12 83 82 51 49 83 37 24 86 2 57 8 72 50 62 93 10 6 79 91 64 62 56 78 38 26 59 90 39 48 36 73 11 82 83 50 15 81 32 66 36 97 17 25 49 26 55 87 36 95 82 62 6 36 47 56 38 49 21 33 50 15 35 5 28 25 5 65 56 59 20 89 9 53 48 79 27 42 46 80 85 29 31 16 42 58 70 23 99 45 57 63 45 42 18 77 37 90 82 13 97 69 74 40 86 48 12 93 37 36 76 99 25 99 70 91 35 20 67 26 53 72 6 56 81 37 43 47 15 50 59 56 23 31 99 96 20 62 44 56 12 99 27 58 9 92 65 99 13 22 7 23 37 58 86 38 14 99 51 65 53 85 59 58 45 78 8 4 98 89 65 88 57 95 4 37 66 21 40 53 88\n 19 54 32 94 45 34 45 90 57 35 18 59 67 15 48 31 12 45 76 1 15 69 93 89 56 58 77 42 62 16 23 26 41 28 98 93 89 32 14 42 35 77 81 82 40 99 56 99 4 45 82 10 27 87 38 21 11 26 80 64 13 82 42 13 32 84 97 4 90 25 96 38 90 52 42 8 15 6 65 99 87 77 76 24 42 13 78 50 46 30 72 4 13 16 59 17 38 30 14 77 31 60 29 7 79 26 86 64 42 96 90 44 71 35 79 12 44 36 38 21 91 45 77 64 50 43 47 21 96 30 33 65 90 79 65 93 80 3 20 60 35 42 15 11 24 57 77 73 72 37 44 22 76 36 7 55 51 9 6 23 46 32 78 81 47 98 94 3 32 50 66 90 59 27 82 59 84 50 71 88 72 4 25 22 17 82 7 56 37 40 41 1 78 24 64 26 19 45 88 35\n 64 34 36 4 18 22 74 69 34 60 42 43 68 12 35 55 11 28 23 64 10 69 17 66 99 99 5 73 71 68 2 29 53 88 7 36 64 87 7 14 82 6 34 3 76 22 55 99 95 95 43 9 96 80 44 75 6 43 71 17 59 29 88 63 82 86 79 14 59 32 2 48 66 37 45 35 22 89 56 53 19 86 35 74 48 77 9 22 64 45 89 94 7 70 42 80 54 17 46 20 56 33 69 44 24 15 82 59 43 17 54 39 72 92 22 27 14 8 95 86 63 71 78 48 90 44 15 77 78 96 43 22 28 39 89 45 49 5 62 10 32 58 76 22 68 55 72 18 24 62 25 5 79 50 22 70 70 59 90 83 98 20 19 57 76 95 64 84 53 1 97 72 32 83 22 34 59 4 3 90 45 37 23 33 92 32 7 27 61 86 38 73 9 64 92 39 51 13 23 88\n 3 78 62 60 14 24 65 77 29 21 9 81 45 16 42 33 40 27 94 20 50 89 26 42 5 60 81 34 54 11 80 95 37 45 58 89 31 53 96 68 21 16 76 84 27 97 31 46 90 46 24 48 64 31 17 49 49 33 98 2 7 15 98 21 15 90 34 82 84 44 69 8 97 11 68 77 2 7 80 47 65 62 72 45 17 17 58 21 23 36 13 74 69 73 26 35 49 4 95 85 70 42 52 89 64 90 13 5 2 99 33 4 27 84 72 12 74 41 96 96 30 68 5 23 40 36 70 7 8 52 38 43 91 29 64 26 85 84 20 57 55 76 41 84 34 39 24 58 26 2 55 52 17 63 9 86 17 35 96 61 96 89 94 49 16 49 85 44 95 51 95 33 95 81 55 24 47 17 72 41 62 16 29 81 88 21 2 33 25 52 92 54 24 65 1 40 59 47 52 62\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 1342855162 11456 11194\nprocessing times :\n 68 80 35 21 90 63 73 35 11 20 40 46 47 9 59 93 88 10 80 69 86 91 16 85 83 98 28 6 73 30 30 6 33 25 37 90 57 65 90 86 74 76 55 83 25 13 70 47 60 83 12 69 66 57 98 59 18 10 62 88 86 55 48 88 17 34 36 26 42 34 89 41 81 10 18 50 34 7 91 41 84 76 56 2 77 42 43 69 1 91 26 13 76 57 63 95 89 7 25 79 16 68 65 75 72 61 53 69 2 2 9 96 38 83 35 28 38 93 47 87 27 66 63 21 84 37 90 61 94 78 31 38 77 26 46 40 14 6 98 18 13 42 6 99 44 59 16 38 49 28 73 94 47 31 56 1 59 59 53 98 50 10 44 12 79 55 68 9 57 82 67 89 77 83 26 73 94 67 30 77 97 6 48 76 91 76 85 48 17 43 54 69 85 60 82 59 71 45 76 3\n 69 7 4 78 42 80 94 94 19 84 81 55 19 52 53 38 40 74 94 4 47 34 31 79 97 45 29 13 20 32 81 20 85 87 58 77 76 90 15 33 33 69 5 22 18 77 32 31 67 8 87 61 89 87 81 28 85 2 34 26 84 10 61 1 24 19 43 17 33 15 62 46 97 99 82 54 84 60 92 32 18 57 30 59 14 20 93 32 56 1 89 85 95 4 21 59 79 18 88 65 3 23 16 87 15 17 84 12 61 71 32 95 1 47 37 56 3 66 26 80 57 92 9 26 36 93 11 86 24 73 14 58 93 66 53 5 65 27 56 38 80 51 41 20 85 28 72 99 87 95 45 65 17 63 27 65 19 57 54 64 39 48 14 9 39 40 41 3 98 61 21 46 30 78 15 96 90 86 16 71 14 68 78 46 97 4 37 15 32 18 80 7 26 42 83 27 79 92 16 37\n 52 18 43 47 87 37 61 37 38 1 77 25 90 54 87 41 90 3 85 63 12 99 11 4 53 58 13 1 1 68 93 37 61 83 15 78 72 69 86 1 14 66 99 5 29 5 38 76 50 40 51 91 89 96 86 66 73 97 7 91 99 58 50 25 47 47 46 11 24 27 39 86 60 15 14 87 87 46 67 27 1 23 87 58 97 36 78 41 79 56 28 65 69 88 85 85 67 30 40 19 37 18 70 78 22 77 45 10 38 90 73 27 40 79 4 16 54 37 68 37 94 49 78 38 62 36 24 4 73 62 68 57 18 52 52 62 76 93 90 72 85 97 16 50 61 75 80 34 30 63 51 36 67 78 45 45 72 67 15 79 61 10 4 65 51 16 26 42 7 5 36 92 15 79 73 32 73 10 94 98 6 51 4 13 36 43 60 68 16 25 49 44 10 21 60 54 91 65 18 22\n 6 8 77 92 26 13 37 77 77 21 12 45 70 73 55 49 19 41 44 13 99 51 22 80 14 88 79 24 41 66 71 69 86 61 4 13 28 20 86 28 87 36 60 18 13 33 68 96 34 12 22 49 25 41 76 74 2 73 31 68 40 60 6 25 17 8 77 94 65 81 42 81 46 5 94 22 86 80 4 31 87 6 59 86 26 11 33 21 4 53 7 29 90 85 31 21 44 62 21 54 45 17 12 30 35 81 68 7 70 5 94 75 59 60 48 7 8 70 28 61 12 30 45 70 18 19 13 8 96 63 60 79 80 8 19 54 11 4 43 1 6 9 24 72 85 12 49 98 19 51 5 9 92 50 45 14 7 62 58 39 31 76 34 53 40 5 40 46 65 9 10 86 48 1 21 49 14 79 32 11 15 13 87 67 57 87 41 87 60 42 97 16 40 76 62 12 24 43 56 8\n 67 36 31 57 42 16 61 52 11 42 14 96 78 60 25 45 9 75 3 17 17 67 56 36 11 2 37 93 13 20 8 10 68 90 87 91 71 58 80 24 51 51 47 88 84 92 72 64 62 60 80 51 12 69 38 18 50 98 78 89 75 75 69 60 11 4 74 40 75 81 19 32 54 16 11 67 21 88 60 44 24 87 50 29 30 53 98 99 35 49 86 4 40 83 39 24 33 29 16 60 35 24 46 34 98 20 77 78 42 40 39 22 24 96 79 23 34 22 55 48 41 33 65 41 42 4 65 23 14 72 6 85 32 34 19 57 7 30 70 11 27 25 62 36 15 6 60 45 5 93 49 33 15 15 61 99 79 56 57 37 26 78 68 60 57 26 10 9 33 92 59 85 3 24 35 37 24 45 28 99 67 53 78 20 92 65 84 88 88 11 81 15 29 69 93 86 74 47 5 13\n 96 38 99 92 83 1 68 87 23 59 67 3 22 5 52 70 64 52 48 38 76 35 18 91 62 28 92 71 53 23 91 46 96 62 30 17 79 52 93 63 78 65 7 61 42 65 1 73 60 64 11 60 2 10 56 6 98 98 19 3 37 84 28 68 40 59 39 33 49 10 55 98 76 79 63 99 35 97 79 45 97 45 86 67 3 34 75 25 3 66 37 41 39 64 95 46 99 98 6 31 48 64 55 26 47 69 98 47 18 81 34 94 64 51 77 71 37 88 64 7 45 8 74 41 2 46 68 88 42 4 17 84 62 20 81 64 3 18 42 9 21 23 69 74 34 32 72 4 6 56 58 98 53 14 76 43 6 32 26 52 11 97 44 8 17 83 48 46 65 89 88 78 7 6 72 93 73 71 55 7 69 39 4 96 33 74 61 90 83 8 60 89 44 20 56 17 36 16 20 19\n 40 52 74 13 37 64 40 59 34 58 90 57 83 14 73 56 56 32 21 56 54 1 36 95 21 80 39 63 90 52 3 77 93 22 56 39 79 3 95 14 50 86 77 40 93 25 72 46 15 67 65 38 64 91 69 33 38 1 5 64 76 20 80 19 13 69 30 36 90 24 98 1 87 69 44 86 2 99 46 38 81 77 15 73 24 32 94 90 12 32 74 93 49 16 16 18 70 71 13 3 77 39 84 96 88 65 84 93 22 16 46 8 49 7 18 21 16 56 83 73 93 19 78 47 37 73 82 77 37 30 79 86 97 70 42 38 40 92 88 62 69 30 28 38 68 7 16 11 51 67 99 78 1 68 61 39 83 71 98 62 23 42 21 76 81 48 78 4 42 54 88 89 70 71 4 30 91 98 66 55 36 78 13 68 41 26 42 1 76 21 3 61 85 58 63 70 32 96 99 35\n 89 27 85 52 35 27 72 25 32 7 8 10 23 45 76 71 80 4 87 69 65 17 47 94 90 7 35 20 8 59 54 88 51 23 24 91 21 64 53 55 98 23 8 13 85 74 26 1 10 80 97 66 49 70 60 91 64 56 44 70 10 98 16 64 8 39 70 88 88 49 26 38 41 39 4 8 39 44 55 23 99 57 45 84 69 30 34 97 48 11 46 51 9 31 48 5 30 46 49 36 66 85 18 42 50 57 56 11 28 16 58 96 88 22 57 58 94 12 17 24 56 50 71 37 32 1 98 93 36 41 8 94 51 47 92 43 11 66 77 29 31 27 93 68 93 4 29 74 87 56 82 18 53 63 26 19 97 86 29 47 86 20 38 21 24 31 21 62 79 89 56 60 76 54 38 10 65 65 85 58 51 4 78 25 46 34 20 27 27 26 61 16 47 61 72 52 67 93 44 11\n 59 17 27 53 53 73 84 45 80 49 95 52 7 41 17 24 1 53 9 54 88 15 47 75 71 46 29 51 3 54 89 73 48 1 96 52 28 4 33 51 6 58 18 14 65 37 82 5 78 31 19 72 91 20 78 60 26 37 72 73 70 74 58 32 66 65 8 22 39 79 74 17 23 93 55 6 6 10 96 47 84 71 14 70 33 31 23 50 28 96 51 77 55 64 93 31 85 33 46 57 41 88 84 7 10 43 36 77 34 37 81 57 96 53 95 7 54 85 71 28 93 39 92 13 90 24 82 41 49 51 20 14 59 68 93 96 9 47 97 25 68 99 72 92 60 56 11 85 41 31 22 83 79 67 19 96 85 19 10 33 25 25 42 71 95 56 94 20 42 66 66 62 12 5 27 60 16 58 92 58 56 21 88 47 51 14 4 53 29 31 42 69 42 55 38 50 78 67 15 7\n 52 26 37 98 92 91 17 76 44 23 50 1 66 86 37 92 80 54 21 80 69 65 40 78 57 29 23 52 73 48 10 51 60 77 12 45 37 96 34 88 63 6 31 40 32 33 14 18 91 38 57 20 98 32 46 83 98 65 23 75 85 77 87 49 28 11 92 45 55 80 63 10 30 13 41 5 30 16 14 84 19 91 67 49 71 85 11 27 43 93 80 80 85 3 73 94 9 68 22 60 98 87 5 42 94 30 98 77 1 88 33 18 79 14 6 43 25 68 29 21 20 70 6 49 77 1 62 91 78 12 90 3 35 58 95 9 8 51 45 67 86 91 79 5 65 75 11 58 25 36 55 30 56 54 74 78 75 38 20 77 11 91 73 46 13 94 73 46 58 30 90 80 85 86 20 67 99 58 81 26 14 61 74 20 87 44 89 53 23 91 86 43 11 47 51 5 25 21 39 21\n 39 83 12 57 78 55 20 79 58 52 99 48 87 67 95 82 90 41 86 97 27 20 82 45 71 58 92 5 21 45 43 12 53 29 14 49 85 90 12 48 13 75 69 34 19 55 44 22 60 45 38 78 73 59 46 47 95 25 58 61 92 8 88 64 93 29 20 45 46 78 37 49 2 18 92 41 31 29 92 87 65 22 61 90 89 97 15 75 77 65 21 56 53 9 86 75 7 88 38 69 57 2 75 44 30 39 88 35 13 21 38 6 92 43 22 85 51 25 43 4 81 31 71 92 25 72 42 77 70 66 15 15 51 78 89 50 74 57 7 65 89 87 6 31 70 25 36 88 25 94 66 95 77 10 26 58 8 95 20 46 49 37 76 11 24 72 75 58 46 2 83 14 77 68 81 81 56 37 41 96 53 88 66 50 40 28 65 76 89 16 48 91 83 84 18 2 63 27 39 14\n 30 34 55 12 50 15 4 43 74 31 72 71 29 28 32 14 32 6 46 73 48 56 97 56 60 72 24 29 64 29 3 97 50 97 83 89 2 96 28 83 47 90 56 57 69 88 54 94 90 62 97 67 59 22 24 87 99 62 18 70 94 85 43 48 51 91 16 31 57 51 9 28 37 89 83 33 94 44 76 82 10 81 74 55 92 26 27 86 32 28 75 67 91 48 58 23 17 18 37 78 84 64 65 11 41 31 5 67 91 75 47 78 64 23 29 81 44 80 59 34 35 54 49 14 72 21 57 42 24 88 78 75 53 80 88 20 4 30 52 32 82 28 36 98 77 71 16 91 79 10 28 80 60 86 81 20 3 46 57 58 76 63 13 81 85 82 92 52 8 6 52 12 65 26 67 14 64 8 40 86 47 83 58 83 95 56 65 23 32 43 91 18 27 79 53 87 97 79 99 18\n 42 74 1 40 3 95 69 18 73 66 83 52 37 53 19 3 53 5 44 91 46 43 50 40 30 40 56 40 75 5 81 87 14 61 4 94 22 36 95 79 42 84 92 87 60 16 76 32 88 19 72 10 87 78 75 39 58 71 45 43 34 9 28 7 84 42 72 57 56 25 33 33 80 69 87 94 90 66 93 23 84 84 56 90 58 69 6 31 98 43 34 56 49 98 82 68 32 83 45 77 11 20 3 40 48 24 32 23 25 51 80 23 49 88 35 40 40 63 48 29 19 5 23 14 57 57 40 7 95 53 52 2 43 94 85 75 84 42 27 40 66 48 81 92 30 49 86 26 91 78 41 53 50 74 69 48 91 20 20 53 75 78 91 84 49 39 19 29 77 1 5 84 34 13 19 80 21 87 4 76 91 54 56 9 79 20 62 59 43 19 92 7 94 55 34 14 70 88 58 7\n 3 34 39 69 9 92 78 99 27 20 61 15 87 76 55 23 35 21 28 93 95 25 92 6 54 66 30 32 5 68 86 98 87 15 75 34 86 1 4 60 75 88 11 23 33 20 85 69 32 14 89 12 56 26 57 24 57 85 3 9 5 76 15 62 83 64 46 43 26 13 49 57 37 48 10 13 34 46 56 93 80 84 81 15 86 76 24 39 57 76 81 86 78 94 33 10 27 12 55 97 21 88 54 16 8 34 74 11 24 77 19 12 17 8 59 8 88 21 75 29 83 76 35 19 18 60 84 80 62 20 33 19 85 50 2 39 88 94 67 85 18 31 72 96 88 41 89 76 93 36 4 21 91 76 86 47 89 81 88 41 18 49 22 59 96 70 85 46 75 10 7 5 18 42 92 86 59 90 87 82 10 79 64 50 4 29 8 6 60 79 85 35 35 51 35 24 65 15 11 99\n 74 21 53 51 80 67 91 44 11 71 10 26 62 93 1 9 82 71 79 65 39 6 3 46 36 5 19 70 61 20 3 98 51 3 56 47 46 86 92 92 25 14 1 39 42 23 45 28 9 23 29 94 65 55 80 92 23 25 44 14 54 48 15 45 25 36 49 72 57 14 41 91 72 84 61 97 90 34 13 47 51 51 41 10 81 25 5 85 56 18 36 18 62 55 70 22 21 50 44 39 82 10 53 40 16 63 94 4 54 33 22 95 39 81 93 17 64 94 35 52 31 16 69 85 77 45 83 97 43 64 29 2 27 91 40 96 66 62 75 50 68 1 68 91 50 78 67 23 36 92 65 13 5 62 60 7 56 19 23 84 50 17 77 63 25 17 73 62 10 63 64 25 1 50 7 59 93 95 41 20 69 37 21 91 12 64 94 5 32 26 16 55 75 27 90 84 86 14 7 36\n 59 31 80 74 7 14 53 47 34 53 80 9 1 74 62 6 47 58 60 88 8 88 56 82 42 64 63 10 7 69 92 12 44 93 83 16 65 95 60 60 62 3 44 23 14 98 53 10 31 30 81 46 38 37 64 36 90 93 90 71 15 38 57 63 38 35 60 56 14 17 29 71 60 86 24 14 14 69 18 94 99 13 41 49 20 35 85 9 87 27 28 13 90 46 55 78 52 16 7 15 78 63 21 88 96 44 57 12 3 52 88 61 66 93 29 33 37 60 6 3 14 42 20 19 90 10 27 76 58 67 28 54 66 46 78 91 85 3 49 74 23 60 61 57 79 4 59 53 15 21 73 4 14 52 47 66 93 65 91 61 55 76 64 45 58 25 98 5 64 31 38 37 39 62 57 69 41 25 3 86 97 37 83 78 86 98 22 9 22 44 37 32 3 54 71 86 49 89 27 50\n 37 28 56 33 26 17 43 75 16 19 65 20 28 25 60 64 9 58 5 75 18 35 86 56 99 99 95 22 30 26 41 62 15 2 10 48 93 50 51 39 26 86 21 83 52 25 14 66 20 60 38 48 31 88 5 73 29 95 66 73 84 41 40 59 76 92 63 77 62 69 80 73 84 93 89 90 89 94 13 70 35 41 2 44 94 12 59 62 77 51 64 4 98 42 77 81 20 54 45 15 22 94 75 49 4 22 77 80 35 94 96 38 37 17 14 14 15 88 49 6 14 41 4 61 23 73 6 58 69 60 50 27 64 29 43 88 2 69 17 56 21 42 28 65 79 19 78 20 2 37 90 42 53 32 26 74 95 89 68 34 65 10 63 51 4 58 81 76 48 80 53 53 71 65 3 96 44 67 38 96 54 14 99 64 91 9 21 93 7 48 80 1 46 58 35 27 55 80 40 13\n 24 47 27 99 39 26 24 66 92 98 35 92 26 16 78 25 51 37 62 72 27 71 68 81 5 4 34 35 56 31 81 32 58 10 64 25 69 89 32 25 63 62 3 99 33 57 93 1 35 18 84 53 49 52 57 85 45 84 52 52 93 66 90 49 83 89 76 96 65 60 89 87 71 1 21 35 11 61 34 89 67 54 68 77 29 58 92 40 88 97 46 22 44 97 52 66 28 99 68 4 81 80 33 8 24 98 76 30 48 44 96 97 6 91 38 56 42 37 9 31 56 18 40 85 29 54 96 45 49 85 5 48 45 24 43 62 46 27 5 12 89 34 88 57 6 76 34 67 51 11 82 93 82 48 3 67 55 22 56 62 18 89 21 84 72 66 38 31 38 9 82 88 39 78 9 17 57 22 67 52 66 45 9 67 38 54 10 96 2 58 96 26 99 72 69 11 55 82 59 25\n 64 28 64 11 27 35 19 28 87 11 25 54 18 19 59 77 83 36 71 68 57 28 57 57 52 4 52 40 99 87 46 49 37 68 86 10 41 22 90 93 25 37 19 96 34 1 6 40 34 82 51 67 45 38 74 91 81 42 27 55 66 94 10 81 33 12 90 22 4 65 34 54 19 48 87 65 29 34 85 17 99 80 91 94 79 82 78 64 69 26 60 48 34 47 74 76 38 23 23 53 17 45 27 53 92 6 95 30 2 3 18 16 71 92 41 9 52 18 97 9 22 62 89 53 69 25 48 40 59 3 45 15 70 33 30 88 40 88 13 88 77 80 14 79 87 51 16 96 95 49 44 65 59 49 63 95 81 47 78 34 84 29 72 10 39 80 1 64 89 37 83 66 8 42 97 6 48 46 63 67 9 53 91 50 86 55 38 68 73 68 91 5 58 56 17 35 42 55 17 28\n 75 24 53 31 93 72 83 66 90 44 29 68 38 87 29 86 34 65 47 35 57 11 32 82 42 1 93 41 3 2 43 80 67 6 99 97 70 24 48 9 56 11 45 93 84 44 22 26 70 84 79 82 84 54 27 15 89 88 65 84 28 20 64 43 92 30 33 39 68 85 11 14 65 7 77 81 69 89 12 46 37 53 46 8 28 6 63 48 55 69 22 42 47 15 69 34 25 21 33 93 73 60 24 50 75 58 36 50 91 74 81 70 23 93 66 53 96 77 63 12 35 92 57 32 97 30 73 46 91 52 97 19 28 21 16 81 59 45 63 49 42 38 83 52 92 36 22 49 63 56 44 51 75 34 8 6 48 8 29 8 12 61 60 32 64 13 71 59 91 68 82 98 76 35 78 58 81 26 3 80 90 39 90 32 32 34 69 81 55 13 15 17 87 11 12 48 2 65 35 98\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 1325809384 11415 11126\nprocessing times :\n 28 87 76 87 85 94 64 9 38 60 12 29 65 56 43 4 48 52 74 75 62 72 6 92 86 3 17 59 6 9 51 48 86 68 97 16 98 43 63 98 74 71 79 51 26 70 52 16 5 89 30 8 45 60 90 81 87 32 17 80 9 30 28 20 76 43 18 47 42 97 90 64 95 84 71 8 94 59 85 68 91 40 25 78 91 8 80 80 88 23 13 20 77 99 72 9 56 52 81 39 86 10 33 30 13 61 64 73 67 56 66 55 22 47 5 97 65 84 3 72 19 6 10 21 56 17 75 30 44 34 39 77 72 95 67 37 44 24 16 20 76 66 44 36 5 28 82 87 73 72 36 54 33 44 49 66 27 89 92 97 90 35 53 4 75 26 47 11 27 91 10 37 54 32 50 75 30 37 25 88 99 77 63 76 92 59 23 80 82 77 51 17 48 6 77 29 36 4 65 46\n 99 42 98 23 63 4 7 83 41 23 1 89 88 57 83 2 46 90 41 16 75 57 83 51 47 89 17 25 28 43 7 37 77 82 16 25 44 59 53 47 81 37 10 80 94 58 64 45 59 58 90 37 12 11 51 55 69 53 89 67 49 32 70 85 12 43 68 82 97 55 30 69 30 27 7 36 51 38 65 73 70 68 75 46 62 19 35 35 69 51 28 18 17 22 23 41 64 60 88 85 62 10 93 31 14 19 61 14 11 78 9 38 17 98 30 11 27 87 6 57 77 79 94 33 45 50 38 86 43 91 95 68 11 1 16 19 36 99 38 54 29 8 11 78 60 39 17 17 96 26 17 67 67 69 74 80 61 79 26 42 48 41 90 74 14 94 93 93 56 84 87 90 39 93 89 5 91 79 10 35 19 30 66 44 95 60 33 67 84 73 85 10 7 38 4 18 52 53 4 13\n 41 42 67 84 13 60 6 41 23 15 99 78 22 70 84 41 57 38 97 68 53 67 91 73 33 55 69 42 33 32 67 60 90 49 93 83 41 70 48 78 75 24 15 75 22 74 19 33 19 12 32 7 54 3 93 18 69 55 47 79 11 83 8 71 19 72 24 94 8 72 17 23 1 1 41 17 71 69 68 90 77 93 27 79 79 61 69 18 30 9 69 94 26 33 42 49 51 42 79 81 90 53 43 38 49 82 97 83 34 47 48 24 71 73 3 85 3 71 14 70 62 2 14 94 85 48 84 75 22 81 32 44 92 92 32 5 42 23 92 67 57 57 74 8 66 46 81 7 28 62 56 57 40 6 79 34 80 70 45 81 99 1 33 82 80 89 41 75 84 40 58 33 42 44 63 22 86 5 79 90 96 25 92 1 54 97 73 89 6 67 10 60 52 20 67 43 84 91 31 71\n 28 47 43 94 85 79 33 95 65 3 83 41 94 22 62 33 9 73 75 3 15 97 57 53 33 7 87 10 55 40 4 92 8 99 70 84 77 28 2 32 75 19 73 67 42 60 31 16 78 80 39 1 88 8 1 75 96 42 47 61 59 75 45 49 16 59 1 9 28 14 17 2 44 6 98 75 73 16 96 16 88 59 77 86 59 24 33 53 47 55 35 77 62 1 52 50 8 50 72 65 77 59 49 6 52 71 14 54 45 54 94 84 21 3 70 74 79 81 47 60 60 30 20 81 97 39 24 34 92 58 8 5 51 10 54 5 28 55 63 82 7 58 97 23 96 8 36 71 60 36 25 82 90 16 2 76 66 45 93 19 7 93 78 56 40 69 38 69 25 66 38 11 36 30 84 5 56 65 61 54 86 26 65 62 64 29 5 87 56 27 1 5 1 55 95 5 29 60 62 28\n 77 37 78 25 51 26 3 10 74 75 42 41 64 65 51 29 3 44 65 52 60 13 81 38 10 78 65 51 80 31 84 62 9 29 72 34 46 96 9 3 95 86 45 19 61 18 62 2 77 61 9 12 66 73 36 74 61 7 57 96 2 14 3 29 79 43 64 20 44 87 84 71 88 14 24 88 20 79 83 43 24 92 7 92 68 69 34 30 85 5 41 90 46 20 91 51 86 99 26 95 89 55 85 49 28 21 48 47 12 90 23 43 27 16 26 97 34 99 17 63 48 24 27 53 74 75 51 28 46 82 80 33 33 84 73 6 26 26 67 82 64 76 45 57 37 54 51 7 67 55 69 27 63 98 29 25 44 95 18 20 26 23 37 3 88 57 44 88 20 17 52 86 94 62 75 94 38 36 29 83 95 71 59 31 59 39 77 1 90 29 3 55 8 56 37 18 82 28 54 9\n 72 98 97 31 11 7 88 76 89 29 2 66 12 29 92 35 97 25 50 17 32 74 28 20 42 2 15 16 38 77 69 44 69 89 20 4 34 5 13 6 8 35 75 16 77 18 31 95 62 98 94 65 66 40 74 94 13 64 78 58 44 60 69 17 77 16 27 61 59 84 43 27 63 18 81 90 69 63 97 12 44 48 67 93 54 81 70 39 59 58 41 8 18 91 45 93 19 99 3 60 11 59 62 76 11 23 9 8 90 29 11 8 25 21 55 10 92 32 60 59 5 8 65 57 9 84 88 84 29 48 87 25 64 80 51 53 91 22 36 4 93 39 23 88 5 39 65 56 66 15 5 10 37 86 39 76 64 36 68 8 24 95 2 9 97 48 38 90 89 45 86 89 54 64 29 41 70 91 48 96 19 1 95 72 49 97 37 16 78 13 72 30 23 75 78 50 20 21 68 14\n 80 83 1 66 52 7 80 45 12 39 37 22 71 73 69 15 40 35 29 72 16 79 79 6 16 17 53 87 14 44 35 37 51 65 66 17 69 68 40 85 4 72 66 1 40 99 94 83 21 57 3 34 42 21 90 56 31 69 78 50 27 56 67 15 52 98 27 27 49 60 16 82 43 59 77 23 71 88 48 80 16 81 13 74 62 96 78 82 65 60 77 53 11 61 15 13 54 79 5 54 27 41 50 22 37 3 65 30 94 67 39 24 98 9 28 54 18 32 50 43 80 14 25 7 81 58 48 85 85 77 4 55 17 46 56 50 29 87 40 9 88 39 16 37 5 82 23 67 8 24 61 93 11 96 51 1 8 80 79 63 96 75 94 19 40 81 53 30 99 49 40 26 83 39 5 50 41 57 53 69 56 56 11 92 24 66 74 87 3 82 38 88 77 91 97 12 8 93 54 92\n 5 18 67 66 81 73 15 85 51 44 42 28 19 95 25 72 59 10 14 63 46 37 62 45 9 30 39 84 65 9 7 2 8 93 44 16 41 29 43 88 74 37 14 5 76 23 76 88 45 29 88 71 6 95 70 29 99 2 85 13 77 69 30 99 49 26 46 12 8 37 90 95 9 85 73 2 28 99 79 35 9 27 81 93 79 87 2 28 5 44 33 77 91 33 2 90 14 34 85 83 32 59 16 22 6 59 26 38 3 22 12 14 66 21 52 65 27 1 46 13 30 63 87 2 14 11 41 24 19 2 82 11 30 95 97 20 76 69 79 69 66 34 6 41 83 6 87 75 32 73 59 5 90 26 5 89 5 85 90 57 17 80 97 1 76 26 61 32 77 6 62 62 80 31 52 33 37 72 12 15 50 89 90 45 75 45 52 82 38 15 53 1 69 19 98 80 8 32 30 24\n 5 37 30 15 25 6 78 14 70 72 50 68 74 6 93 83 65 93 67 11 44 42 18 30 75 61 61 38 1 79 37 9 68 21 13 39 98 3 32 53 80 71 42 64 32 41 10 70 61 12 47 24 49 86 1 75 14 42 95 22 47 24 76 99 68 97 74 74 77 10 14 79 12 67 5 40 94 5 29 47 66 51 67 74 1 71 15 98 19 86 92 39 60 29 1 18 24 5 55 3 68 48 42 32 12 83 86 81 20 45 15 92 85 22 68 56 78 85 23 10 43 84 22 43 15 53 12 35 85 38 17 64 85 92 77 13 53 72 43 47 58 59 89 67 97 78 97 60 62 65 58 61 43 34 33 75 42 15 78 57 13 56 83 75 13 90 27 66 95 41 53 11 35 46 5 78 53 97 90 54 66 17 76 39 84 28 52 21 25 43 1 50 63 18 34 48 66 36 23 2\n 23 20 24 23 11 60 83 41 60 43 11 59 97 34 79 70 94 87 64 88 75 8 40 63 55 60 28 46 83 45 5 19 27 65 90 90 9 69 76 70 52 56 98 44 34 60 48 68 16 7 73 50 54 48 31 76 40 80 62 88 49 81 37 18 1 47 54 13 81 47 52 90 38 95 23 20 70 54 8 36 38 10 10 93 30 30 88 56 11 10 20 15 12 24 99 98 73 24 45 84 42 48 74 93 97 22 88 71 41 82 68 35 92 64 95 67 88 78 51 84 22 75 80 53 38 5 10 34 21 74 37 85 4 90 34 74 34 66 51 70 22 79 58 90 35 78 1 26 64 41 33 19 15 49 52 28 63 87 38 25 29 31 59 70 90 80 49 22 1 25 45 56 45 32 44 29 64 5 64 25 67 44 62 38 72 45 75 40 91 63 87 3 94 64 12 51 88 47 2 96\n 7 64 53 45 43 17 97 76 44 64 27 83 78 70 78 17 96 21 7 49 74 2 63 18 16 63 84 17 7 70 56 73 30 45 21 49 32 92 51 20 19 39 37 90 59 5 66 61 81 35 45 93 91 9 75 79 95 93 54 43 74 56 63 64 26 91 71 37 32 8 85 93 56 21 5 82 82 59 28 55 80 39 38 91 77 77 72 59 50 61 29 41 31 22 62 61 89 7 85 82 88 85 98 8 76 76 49 44 6 40 4 19 93 7 94 27 90 53 79 5 69 3 5 15 5 22 84 7 64 85 33 34 5 94 68 99 41 92 70 53 7 55 73 74 94 61 66 46 45 48 60 86 94 29 24 16 78 36 80 31 65 54 54 39 14 94 58 82 47 34 51 43 54 94 88 86 50 5 27 22 59 63 71 8 34 59 92 57 77 52 18 60 69 38 89 1 32 60 92 84\n 82 56 67 11 8 40 68 48 17 41 27 75 91 57 89 41 72 31 71 15 82 6 50 63 26 96 20 13 7 80 18 35 13 67 37 14 36 69 74 46 36 84 11 30 85 62 5 1 85 58 77 9 36 11 29 79 75 34 92 14 71 92 88 26 13 59 63 74 80 4 31 70 17 70 87 90 58 27 11 89 53 17 70 95 76 49 23 74 97 98 76 83 40 46 72 39 21 96 56 52 85 33 97 77 51 66 95 63 9 92 59 79 42 51 82 42 33 3 19 54 66 28 74 11 70 30 37 16 72 62 25 38 23 18 92 27 24 30 44 42 81 84 59 67 88 98 33 92 85 81 6 65 89 87 63 85 79 39 18 41 18 32 76 8 16 58 72 77 98 55 19 53 60 63 14 95 52 54 12 89 60 79 66 84 88 35 97 23 26 52 43 43 55 54 40 7 76 58 1 63\n 35 28 25 36 29 41 11 65 85 22 82 96 59 1 17 16 54 43 52 62 54 37 84 75 36 83 42 53 46 24 96 28 72 72 17 16 27 71 21 59 70 51 58 72 77 85 3 37 63 70 15 10 45 82 17 28 33 84 69 22 19 16 75 22 53 16 75 79 33 28 89 18 43 28 28 51 83 20 3 53 20 56 15 5 85 67 37 89 41 75 18 83 69 97 20 71 63 25 31 45 91 70 32 98 68 38 61 5 21 46 76 57 33 42 12 93 8 90 94 12 43 80 88 94 43 28 60 17 69 19 88 23 63 85 70 82 51 55 12 56 30 87 1 41 84 67 83 98 49 3 51 2 78 37 86 56 9 81 22 11 82 59 4 89 40 87 1 32 28 83 29 90 55 48 16 21 91 40 66 31 92 69 12 15 34 85 72 90 3 1 10 3 74 88 56 60 60 91 34 33\n 24 34 7 25 96 75 84 43 53 13 11 47 24 83 81 46 76 4 57 23 7 44 35 67 28 20 58 96 57 5 78 30 67 75 6 19 46 69 36 19 93 50 87 36 92 13 83 77 98 39 20 32 53 69 67 26 67 58 59 39 20 25 49 27 66 74 25 67 32 7 80 96 73 77 72 17 9 77 37 25 19 17 90 29 9 67 87 59 21 2 32 89 76 19 4 53 45 38 6 27 64 87 83 74 63 29 36 5 39 9 53 23 88 62 21 31 82 93 66 28 59 18 31 83 25 22 18 71 81 15 59 41 91 35 47 56 29 62 70 94 64 48 2 1 56 5 94 96 50 65 65 24 51 63 69 11 67 43 57 40 64 9 25 65 66 94 33 13 81 85 98 15 14 88 56 32 42 28 68 66 83 86 89 60 51 38 40 83 92 51 48 37 26 11 51 54 61 44 21 25\n 86 99 16 19 42 32 68 95 63 1 75 85 86 17 65 24 45 71 56 88 36 34 32 72 8 68 20 39 78 58 28 60 35 84 49 18 89 51 94 53 82 63 45 85 11 47 83 8 53 35 24 87 19 7 69 6 1 8 27 38 47 13 12 14 41 69 94 60 41 54 79 32 33 15 65 11 50 63 57 21 6 13 51 10 1 41 57 79 77 18 55 92 41 62 31 45 36 33 1 63 39 62 1 71 55 6 43 5 13 80 36 31 67 98 67 29 85 54 90 21 26 22 96 75 13 15 20 80 28 26 29 98 56 27 75 88 77 33 33 50 21 90 50 4 51 36 71 50 64 96 96 28 83 13 91 38 13 65 89 5 76 4 68 25 12 84 21 16 49 68 23 19 91 55 15 59 75 45 23 8 42 96 47 53 4 2 15 52 23 20 74 82 3 56 40 20 30 76 14 71\n 67 54 97 2 43 73 22 12 14 62 57 34 20 40 39 36 71 82 82 57 71 46 36 94 84 82 38 54 88 27 92 28 15 71 6 21 67 35 8 74 53 10 24 34 30 30 43 25 33 22 23 69 42 80 55 66 57 43 41 48 78 71 82 59 30 44 45 82 3 18 22 50 61 57 89 80 44 81 84 32 73 77 14 92 14 79 96 87 47 73 34 69 27 16 26 74 61 91 97 78 17 63 37 73 40 85 69 86 57 11 41 43 60 45 33 73 34 14 8 77 46 63 38 41 75 35 50 11 80 71 48 45 60 44 18 48 58 27 40 76 55 95 45 7 62 55 67 48 72 20 12 13 82 12 78 2 50 83 32 35 53 67 62 95 81 71 10 46 89 9 78 75 50 50 45 66 37 78 88 24 36 66 13 52 87 23 4 39 65 67 67 84 66 33 86 85 98 35 64 47\n 96 57 3 53 7 52 63 74 32 72 69 4 91 91 15 40 32 97 54 91 61 20 21 40 7 86 54 32 98 83 5 32 25 59 98 50 71 7 65 21 24 16 52 38 15 99 88 58 76 67 9 62 52 10 22 73 56 80 87 31 40 30 42 55 40 9 5 27 56 61 19 31 81 94 83 22 3 2 36 17 79 60 74 41 62 20 86 34 56 16 84 31 96 47 78 75 67 41 11 40 20 33 82 1 50 23 73 9 39 73 57 41 83 92 31 7 6 86 54 93 59 1 66 91 78 97 42 27 25 41 74 63 73 49 75 42 29 95 88 79 94 71 54 67 48 68 29 48 30 8 25 14 21 71 97 6 28 11 94 46 97 82 58 99 50 72 72 10 45 47 72 49 41 87 57 50 40 25 63 8 52 44 87 15 78 15 69 30 73 34 68 22 40 82 41 15 44 13 19 46\n 15 32 42 98 49 80 30 80 34 72 46 20 93 6 92 12 52 13 10 17 84 29 75 69 35 2 67 52 98 99 71 37 52 42 24 22 30 20 62 93 84 92 75 79 34 85 2 65 83 76 3 89 44 55 94 74 55 10 37 66 7 58 45 93 48 4 69 51 43 33 73 7 74 73 45 89 96 4 4 14 15 41 65 41 90 1 80 75 78 79 85 37 19 69 73 79 16 51 93 53 39 85 40 8 82 55 64 70 17 54 72 79 58 61 39 59 96 41 21 98 22 5 19 43 2 74 69 16 76 96 57 81 86 45 93 79 27 58 87 83 3 91 58 12 63 32 30 67 94 46 26 81 22 66 66 38 61 23 70 83 20 84 64 90 51 8 31 19 51 26 22 43 99 69 70 64 99 89 16 82 63 64 1 21 22 58 21 70 26 78 80 95 46 55 56 8 1 15 85 20\n 4 8 25 28 19 44 46 83 8 16 20 59 48 41 87 28 14 85 37 50 92 2 25 5 73 13 58 40 5 28 51 1 88 33 87 13 14 22 32 63 77 82 87 51 81 80 38 28 62 17 72 35 93 47 52 49 29 40 34 57 21 49 32 20 14 7 3 46 16 23 1 76 16 8 22 59 50 30 59 66 58 43 60 77 54 71 1 47 71 82 38 68 91 32 89 65 61 77 15 59 86 37 52 71 38 37 89 41 21 70 60 99 34 33 58 64 66 22 31 54 33 97 95 43 7 85 34 64 52 8 98 49 20 61 10 56 43 38 69 95 33 53 68 66 1 17 36 47 84 20 38 46 49 66 11 37 93 68 64 56 93 50 27 38 65 45 93 13 48 19 1 35 20 50 92 12 43 23 54 88 92 21 6 72 42 26 96 93 65 33 43 34 32 54 95 48 71 63 80 34\n 13 97 79 20 53 51 91 26 16 61 42 83 11 29 14 45 72 39 22 47 35 70 84 47 78 51 4 75 11 36 36 97 36 3 43 73 27 88 48 84 81 27 43 32 11 9 96 57 61 5 53 62 30 47 7 76 27 7 13 64 80 85 54 87 27 53 56 54 66 24 20 36 77 83 56 5 67 67 95 86 77 98 24 1 66 92 74 45 45 20 96 81 90 54 54 18 7 73 36 82 26 45 46 15 86 45 47 90 62 30 66 47 27 4 15 9 85 79 25 92 67 45 47 88 79 75 4 22 84 25 58 10 98 7 32 29 88 14 45 7 14 6 31 57 8 36 48 24 24 33 28 11 45 68 13 41 42 84 8 38 64 78 12 60 54 52 97 33 50 99 37 58 10 42 11 19 12 33 20 63 94 34 25 97 74 82 75 44 53 70 77 22 41 56 58 46 48 34 90 92\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 1988803007 11343 10965\nprocessing times :\n 11 59 88 53 79 18 19 26 57 7 90 65 7 38 54 32 20 88 16 97 38 47 37 54 27 34 28 55 81 71 2 26 99 59 46 92 16 98 40 91 53 75 11 95 59 57 68 62 94 84 9 78 69 64 16 87 29 95 54 74 33 17 78 71 22 48 26 17 25 55 74 10 60 46 53 25 70 41 51 59 99 96 1 20 46 54 88 82 11 45 45 79 79 43 41 61 60 17 87 55 28 50 8 81 65 75 70 10 16 68 18 25 3 39 55 38 27 46 91 61 15 97 40 83 97 72 28 95 42 12 6 39 53 74 89 36 13 61 83 19 9 95 79 30 88 45 90 81 45 66 73 96 4 76 43 52 54 49 92 5 18 57 39 81 6 11 54 73 34 91 86 65 41 96 1 9 59 96 96 76 3 67 21 88 92 64 18 54 65 29 10 91 34 65 58 84 10 14 56 84\n 76 56 32 41 21 73 41 93 11 31 49 71 91 5 74 31 6 76 66 15 26 52 1 52 57 55 62 18 3 80 91 31 53 48 58 36 14 20 69 88 26 29 71 88 30 47 90 87 83 52 28 72 14 29 5 41 43 85 49 16 75 80 38 79 89 10 61 17 77 76 45 17 52 44 38 56 22 98 75 51 27 89 71 33 92 84 10 34 46 91 34 46 47 10 54 82 36 47 45 46 1 39 4 3 53 28 44 93 13 95 80 73 15 92 51 21 57 85 53 8 20 66 13 34 41 58 88 33 83 60 57 61 11 25 65 1 35 2 59 87 87 54 53 55 2 39 53 39 11 75 1 52 41 19 78 39 94 73 71 45 24 18 11 86 67 53 58 68 57 33 53 80 72 32 89 33 57 38 44 35 80 88 75 92 5 71 79 59 73 8 5 6 37 54 76 7 30 78 27 31\n 47 54 77 78 87 28 74 91 55 35 28 47 83 87 51 12 49 89 1 49 93 13 73 20 26 67 18 32 22 18 64 13 19 73 96 15 18 66 15 39 76 20 90 87 67 76 77 5 90 48 48 93 40 74 10 49 77 22 80 81 33 16 90 3 56 66 38 81 89 18 4 85 65 7 24 29 46 1 22 5 35 55 89 56 35 25 80 33 68 21 8 12 93 71 95 94 76 22 94 5 63 61 44 49 70 33 89 16 6 94 20 35 22 81 20 10 15 84 24 64 76 26 97 62 7 34 47 91 32 32 68 10 94 60 16 20 11 34 63 37 58 55 81 71 1 86 62 35 45 49 33 98 12 7 54 47 89 59 7 34 88 91 71 96 21 27 43 31 62 22 82 13 93 85 36 49 39 57 82 99 69 81 7 3 66 20 83 53 9 31 27 69 75 22 97 70 58 29 14 41\n 11 26 12 27 12 35 71 10 97 25 97 91 93 5 18 97 64 62 60 50 48 24 39 7 4 27 80 68 36 88 49 88 44 86 33 51 69 33 38 98 8 73 95 11 73 34 68 48 92 76 60 12 64 50 64 87 97 14 2 26 4 79 87 51 32 69 41 35 19 23 16 15 62 6 77 54 66 24 10 76 16 31 61 78 27 28 57 4 71 45 37 84 87 94 78 61 58 60 85 15 17 71 24 99 69 49 8 61 59 57 25 39 35 91 80 78 96 46 99 57 76 87 10 27 48 62 9 52 45 41 93 56 88 6 17 4 78 92 40 40 29 83 64 46 81 73 1 38 62 37 13 95 29 16 42 77 50 72 98 77 70 72 37 49 26 7 29 54 86 17 68 89 52 37 61 80 43 86 20 97 25 97 83 2 69 31 80 92 47 19 39 10 88 85 76 29 44 98 26 68\n 57 13 7 39 24 61 98 31 49 34 4 37 68 99 47 67 48 89 23 60 51 86 19 80 62 79 47 87 32 53 24 89 58 20 72 83 67 2 37 3 36 13 18 36 35 56 48 57 51 12 88 28 17 53 67 52 14 89 66 96 44 90 17 25 74 76 74 92 23 11 95 2 75 2 6 55 78 82 46 28 68 78 54 70 78 2 75 1 94 93 38 24 14 49 93 23 22 46 25 4 2 56 80 12 7 51 76 69 91 50 30 43 4 39 66 11 41 65 93 28 43 34 58 23 11 79 20 46 87 7 39 28 2 96 40 77 92 61 88 81 97 34 92 87 45 45 18 22 36 96 18 68 52 54 91 75 63 82 32 43 89 18 56 66 9 74 78 55 80 74 36 65 51 50 21 94 3 51 91 76 39 64 67 31 15 51 91 83 72 1 49 4 36 98 91 89 34 96 6 67\n 30 17 25 58 55 90 85 20 33 52 6 34 59 8 31 54 4 54 40 59 14 85 60 63 6 74 72 53 38 27 1 36 98 72 16 22 5 31 93 6 76 29 50 31 53 87 78 79 98 27 94 45 22 8 34 66 21 59 70 93 1 32 92 60 42 14 52 11 59 11 15 19 36 52 57 88 57 93 86 50 62 99 66 60 62 28 48 27 2 27 4 19 84 33 84 15 54 36 27 51 27 67 87 72 80 14 66 91 91 38 88 62 55 47 63 33 98 46 92 3 14 84 88 59 48 36 44 65 37 29 96 2 77 20 39 22 16 43 66 76 92 37 73 70 10 17 14 2 62 70 73 81 40 9 20 82 51 13 76 97 31 11 78 92 97 9 74 24 87 80 17 10 51 56 7 52 26 74 79 83 90 91 64 15 49 39 22 88 88 15 54 46 28 24 72 68 98 30 19 90\n 73 97 17 28 33 4 36 65 48 21 9 74 45 42 80 1 86 91 2 41 42 82 14 13 12 36 83 29 35 29 86 17 90 88 58 48 81 76 19 62 68 82 7 65 12 19 21 74 45 6 35 27 20 45 23 4 35 69 49 33 29 49 67 26 57 30 94 57 5 26 19 3 73 13 6 36 25 23 83 73 10 76 70 38 68 30 87 30 31 63 60 16 8 41 64 19 48 19 67 72 48 77 88 88 48 66 19 45 78 8 57 62 19 15 49 62 17 89 55 63 4 30 17 91 46 86 64 91 32 35 31 68 70 49 68 99 77 86 70 43 46 54 31 53 84 46 38 56 56 65 15 75 84 14 98 99 33 49 49 3 63 57 44 17 73 13 68 7 83 59 74 71 59 25 3 17 11 68 12 32 68 46 29 64 28 50 83 86 36 15 55 86 94 24 33 24 24 26 54 41\n 66 33 71 10 76 25 83 70 87 25 44 25 8 26 99 91 14 87 31 53 78 28 43 91 33 66 81 63 21 47 98 8 88 53 51 3 54 64 24 85 52 43 40 20 32 40 12 83 81 8 21 51 95 9 13 98 41 32 75 69 3 95 32 70 76 52 10 55 12 43 55 85 56 85 95 27 21 38 29 19 49 53 18 60 57 36 56 16 85 21 87 48 14 36 14 25 24 86 74 63 85 58 45 92 60 4 4 75 15 50 73 86 52 78 96 49 61 21 24 21 77 90 36 47 6 41 15 67 65 78 57 20 96 96 73 99 97 47 69 57 40 37 44 6 20 74 23 7 9 78 48 10 21 89 25 75 35 37 65 88 84 74 70 20 80 16 74 70 46 36 79 24 29 39 93 49 1 88 25 86 78 51 79 15 93 26 48 53 28 43 80 84 88 83 91 7 2 38 22 49\n 40 12 72 58 55 74 39 86 98 2 54 46 82 82 51 11 54 66 67 87 21 11 65 22 35 28 45 24 74 12 72 30 81 24 75 49 17 15 47 59 61 72 35 43 70 8 84 8 97 10 97 73 86 23 54 68 36 73 44 73 62 34 98 34 76 36 35 69 11 20 43 99 66 50 45 60 2 11 68 56 46 40 34 4 65 94 85 68 77 39 58 78 6 91 43 62 90 90 57 53 63 30 4 94 33 33 46 79 17 50 68 45 89 80 33 63 26 82 51 92 61 27 46 66 85 69 39 98 67 82 84 80 35 59 2 50 62 8 58 8 1 98 33 83 50 12 56 26 91 51 36 95 36 75 64 54 1 31 31 11 78 38 31 48 54 21 74 30 56 42 11 13 34 72 61 63 31 55 88 87 58 1 42 32 2 19 66 67 75 5 98 9 91 22 44 13 57 42 5 80\n 81 59 68 80 69 28 5 97 25 17 54 68 30 28 13 52 62 7 68 69 22 88 27 72 51 79 33 56 35 74 44 11 58 69 86 2 2 3 70 34 16 22 91 24 50 76 39 79 28 54 34 68 94 13 41 68 44 40 46 60 93 32 83 2 88 71 56 63 25 30 29 47 40 30 66 54 40 63 5 47 88 36 15 20 84 82 44 50 30 84 71 5 35 67 18 27 85 8 63 6 67 80 95 20 22 12 64 30 80 73 12 87 81 39 79 35 93 17 90 50 86 68 53 27 91 67 98 35 64 5 47 13 91 54 82 44 86 38 26 96 52 1 40 58 64 10 89 30 18 74 13 20 44 73 21 34 99 56 77 7 40 84 42 42 14 71 29 32 22 6 58 40 24 22 17 40 80 2 1 62 21 32 77 42 9 93 3 34 39 34 46 30 70 47 93 78 97 47 52 44\n 45 19 74 88 78 38 11 43 84 25 9 91 88 3 78 8 58 47 51 4 29 25 34 62 98 63 97 58 93 61 71 83 52 40 99 53 13 66 13 77 28 98 56 96 94 4 68 65 22 23 28 94 66 2 56 31 62 28 6 10 76 55 53 96 2 88 79 44 83 79 83 34 21 64 37 47 5 52 76 69 37 39 39 2 47 30 38 76 59 81 15 17 87 83 70 2 64 91 48 4 85 12 5 54 66 36 99 49 74 1 81 68 16 80 29 54 9 18 68 88 57 47 77 42 98 42 78 61 81 86 17 58 38 30 32 51 53 32 38 84 19 86 88 63 69 43 19 89 70 48 55 46 95 51 98 7 16 51 68 16 60 53 37 36 94 70 64 35 48 68 74 1 35 67 74 76 94 6 95 36 13 66 74 52 75 2 59 7 90 15 96 29 1 23 89 36 26 25 82 26\n 8 48 72 23 41 13 9 5 76 54 32 40 74 34 78 58 34 23 15 22 87 26 98 40 79 5 12 90 65 17 31 82 90 91 33 30 69 36 87 78 25 70 98 97 24 89 15 22 56 77 49 48 26 71 22 36 61 4 39 55 62 94 47 66 50 94 10 8 18 54 83 69 99 77 89 14 79 36 12 81 37 6 18 32 83 55 30 53 39 68 42 39 44 44 5 37 36 79 85 34 42 32 94 53 10 11 54 2 58 49 64 68 47 99 20 98 46 91 57 76 64 8 32 42 54 52 88 76 60 24 55 62 59 81 19 47 74 78 4 15 24 51 84 10 63 13 98 74 78 85 44 2 67 3 13 48 25 39 1 10 51 22 79 88 80 48 37 66 29 35 15 17 48 16 47 75 75 75 82 63 96 36 86 98 13 22 58 45 39 34 92 32 8 97 50 38 15 75 44 76\n 53 48 74 21 97 28 98 2 95 47 63 33 58 17 58 23 92 14 35 40 86 1 67 60 16 23 93 3 56 22 50 29 78 59 94 71 56 30 87 7 68 62 83 36 15 13 94 31 61 12 78 86 32 24 92 60 26 62 88 96 44 6 26 29 33 98 37 91 88 23 40 84 65 11 3 30 12 72 41 43 59 95 2 55 11 56 25 98 29 59 82 48 55 13 13 51 71 57 15 37 43 82 22 28 89 56 47 39 93 60 23 85 49 14 22 6 19 90 44 66 40 52 48 48 32 4 72 45 57 91 35 83 10 33 20 86 36 20 28 61 51 74 14 44 56 22 80 45 75 11 42 40 50 96 70 56 73 54 8 35 51 99 46 65 65 25 49 12 55 46 94 80 99 26 98 62 64 16 81 25 68 5 95 68 92 11 83 82 57 82 62 9 45 90 68 42 29 8 49 34\n 51 74 32 88 94 95 75 37 82 82 46 92 57 97 48 93 21 1 65 4 75 71 98 88 25 75 43 42 78 70 80 83 11 25 73 73 22 82 97 92 96 81 35 76 64 1 65 93 13 42 65 61 14 26 82 48 15 18 44 58 9 71 29 30 23 62 16 72 63 26 65 49 36 47 47 58 50 32 80 11 98 60 96 96 11 21 21 62 26 98 1 47 4 33 79 64 52 18 60 28 55 53 89 85 3 40 36 73 87 45 69 45 7 90 59 24 18 66 35 22 16 13 34 65 23 95 82 64 55 38 1 64 65 78 39 5 58 78 38 95 95 68 10 66 43 63 11 31 27 66 21 65 50 32 33 79 58 26 45 25 24 62 90 79 9 43 50 55 83 81 62 9 20 64 59 45 26 10 39 64 68 63 47 7 69 28 49 97 80 7 90 5 33 92 81 99 53 2 35 43\n 23 12 96 74 3 36 88 44 83 30 98 65 16 23 82 42 28 7 12 47 75 2 36 73 27 48 58 69 24 4 51 84 29 54 50 84 2 46 97 45 35 68 68 79 51 66 76 4 95 44 66 92 71 21 85 66 32 46 98 80 70 79 51 59 7 5 25 22 28 16 13 61 87 86 84 1 56 18 70 82 80 83 43 11 94 17 75 87 71 20 89 8 84 73 52 8 96 36 27 60 66 32 70 2 83 75 66 47 71 34 13 73 6 35 95 66 33 27 35 20 63 60 76 8 39 65 18 86 75 62 12 18 32 57 4 57 83 45 98 33 41 19 76 33 99 64 12 11 8 63 52 8 3 22 13 7 80 89 79 6 47 36 11 40 18 70 43 12 41 96 30 84 28 71 42 33 83 95 98 19 58 42 25 71 81 95 85 93 43 37 3 8 37 18 78 86 39 68 65 91\n 22 7 7 83 15 48 45 20 13 91 83 48 36 13 69 23 40 51 69 16 18 34 72 68 31 43 91 93 46 19 42 64 82 16 73 48 81 41 82 7 41 87 60 50 81 27 58 97 73 4 18 20 93 46 28 94 95 31 59 23 8 22 93 95 53 63 25 79 8 43 39 34 14 47 76 43 75 66 81 92 44 88 13 80 66 55 19 97 54 95 98 6 45 5 84 51 72 36 58 99 27 53 71 46 36 36 46 59 85 35 47 23 25 34 27 34 49 27 47 7 9 99 46 9 14 66 57 16 84 88 72 80 55 43 52 63 76 96 94 34 16 89 9 11 46 32 58 27 77 58 14 25 34 75 72 56 39 91 57 7 28 29 87 40 8 1 72 52 19 40 69 77 37 14 11 86 96 39 34 2 95 58 13 33 78 75 61 58 17 92 87 31 28 87 55 97 9 39 14 94\n 13 29 22 73 28 19 64 15 51 37 14 78 55 38 75 1 68 16 50 28 29 69 10 1 4 69 90 17 11 57 48 11 49 30 98 40 80 84 99 17 67 63 21 4 73 96 42 24 14 54 39 98 42 55 50 26 60 26 89 69 55 47 57 15 86 13 66 84 71 58 60 23 38 33 88 10 96 69 2 23 19 16 84 13 5 72 24 72 19 3 50 4 31 5 35 95 71 38 66 35 76 46 83 85 35 58 42 53 99 17 56 41 12 51 82 62 61 62 54 17 37 45 48 24 81 28 55 12 25 20 44 89 68 28 55 35 60 33 75 16 21 75 80 58 26 76 7 71 94 81 81 42 14 57 59 28 33 2 93 78 2 33 83 55 29 5 28 46 57 24 35 18 46 93 88 95 82 68 94 53 45 95 70 80 79 28 11 54 43 8 53 70 96 50 47 90 38 85 60 56\n 26 12 17 81 12 7 61 41 88 41 19 41 50 29 8 12 57 90 91 45 24 16 25 38 36 60 35 55 35 45 39 96 50 3 13 88 4 99 68 23 62 27 42 37 78 21 73 97 21 76 16 53 95 99 20 47 76 2 62 90 83 51 23 49 32 56 12 40 63 75 17 90 2 66 98 81 63 52 72 21 42 61 89 12 93 62 54 88 25 98 48 91 50 32 86 25 86 12 1 29 36 22 9 79 39 70 54 56 7 97 59 87 18 16 80 23 15 78 60 37 78 63 39 69 29 24 28 16 31 9 68 25 86 12 52 58 19 8 15 31 19 8 77 17 40 48 97 63 40 26 13 41 68 9 55 93 75 20 94 3 62 66 84 81 52 29 68 64 65 58 68 72 34 85 44 53 11 10 20 25 31 81 80 73 38 58 87 55 17 37 74 76 88 1 26 77 66 85 23 79\n 54 46 1 82 80 54 11 8 78 20 31 84 71 25 11 54 80 54 67 52 72 66 81 15 67 72 66 85 84 37 84 45 20 14 80 1 61 60 21 91 66 84 47 99 20 86 98 90 68 17 35 36 34 17 19 79 77 28 32 50 94 20 72 78 45 24 81 35 36 43 82 29 1 6 52 70 87 44 46 72 7 48 13 2 6 96 24 27 68 76 22 40 44 78 70 91 69 5 32 43 62 90 22 83 58 92 24 44 37 15 52 76 56 87 43 48 28 96 73 78 55 14 69 53 90 91 23 17 42 1 77 86 25 13 16 42 19 40 98 13 40 3 88 71 26 57 25 46 87 32 8 56 49 22 59 16 79 38 42 95 70 65 30 61 16 94 95 67 79 49 62 50 7 32 56 82 92 78 20 17 54 63 64 93 29 77 37 28 92 97 55 70 78 20 18 27 49 26 68 71\n 26 54 50 66 23 90 38 4 19 53 32 92 43 56 92 60 23 52 52 10 84 18 41 2 31 31 83 23 50 75 72 39 93 92 25 60 34 91 15 56 12 81 47 70 51 42 86 1 71 30 65 49 92 11 48 25 26 40 29 86 7 85 31 21 55 5 95 86 89 27 17 85 60 89 96 87 23 8 53 40 93 84 57 5 58 55 79 44 31 17 83 38 79 66 35 60 11 9 31 43 41 64 39 70 77 52 38 22 97 34 31 67 43 34 15 33 19 69 14 13 39 8 84 53 74 78 16 83 14 52 41 20 84 80 1 49 73 55 28 98 98 59 2 26 22 69 7 26 98 56 40 63 11 70 68 69 87 56 8 52 65 79 22 28 3 56 31 44 58 73 79 13 35 5 67 40 85 85 82 5 70 72 5 24 47 53 47 84 11 1 56 19 71 82 89 41 59 46 6 36\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 200 20 765656702 11422 11122\nprocessing times :\n 31 6 1 38 93 48 70 22 77 9 86 40 38 13 18 8 96 86 65 14 34 96 92 97 73 4 95 5 60 2 83 34 56 3 16 7 45 4 17 74 42 69 13 5 24 42 13 30 75 57 73 63 71 70 20 93 94 89 54 29 14 67 16 56 54 49 65 6 89 70 86 16 39 85 35 59 10 79 51 14 97 3 82 39 42 11 56 32 42 59 54 94 16 9 11 27 73 90 46 39 90 18 14 67 68 15 60 57 75 95 69 23 23 33 66 67 40 20 76 18 8 63 57 64 18 49 7 56 95 31 9 1 90 94 63 90 78 75 36 71 18 12 32 47 69 53 48 82 91 71 20 78 31 46 43 98 64 91 11 49 28 7 23 94 79 51 68 7 24 59 35 97 52 40 90 91 40 35 35 55 91 90 61 68 43 91 86 5 46 85 25 73 65 70 6 38 46 25 32 37\n 67 80 76 74 79 91 68 87 22 95 45 47 67 24 70 84 77 7 5 94 10 42 64 74 17 84 7 59 51 42 70 95 76 83 86 58 60 89 78 97 44 10 82 26 14 32 25 25 30 22 27 20 15 72 48 71 3 3 21 69 94 43 93 61 40 83 92 30 86 1 41 2 68 50 91 63 93 82 74 73 56 89 73 26 72 36 83 17 94 65 82 84 64 91 73 57 15 50 47 67 19 39 66 26 60 89 49 51 45 54 98 87 23 20 68 63 14 3 32 6 55 79 43 33 90 66 25 34 63 60 9 34 30 80 11 86 27 96 16 57 2 93 81 76 7 71 59 90 8 38 45 45 5 26 70 33 36 14 32 60 66 20 66 29 52 47 10 61 41 46 9 17 91 5 18 95 10 23 47 66 67 36 23 18 96 98 58 37 18 12 57 24 98 60 29 16 62 97 86 79\n 84 52 21 39 25 54 8 4 61 43 64 50 34 65 43 56 24 56 9 16 55 83 68 51 59 96 26 75 21 58 33 13 59 48 75 75 30 91 70 8 25 17 96 79 52 89 76 73 66 12 24 65 66 53 35 12 63 14 97 45 37 61 37 63 91 45 45 65 28 2 10 50 51 25 93 26 16 26 5 17 9 76 95 55 70 8 32 61 38 32 4 97 97 24 3 20 86 12 66 96 83 36 89 86 49 29 5 55 34 63 22 35 65 40 55 91 88 89 32 47 5 36 26 34 48 66 93 90 26 14 39 9 30 98 93 86 75 54 99 3 85 34 90 75 74 91 10 99 71 89 26 65 58 46 33 5 16 82 45 14 2 22 19 57 83 76 97 73 34 99 22 85 46 65 74 79 81 52 97 67 86 59 66 49 50 23 40 47 24 69 56 67 51 93 87 17 64 74 38 57\n 38 58 1 71 80 63 65 72 51 4 47 9 63 62 25 25 74 31 55 45 12 57 86 56 26 98 40 77 85 11 17 4 99 85 44 71 39 62 38 91 31 44 76 41 26 9 58 56 76 38 25 51 83 64 94 58 55 96 2 21 10 91 90 26 84 63 27 76 99 70 64 75 99 91 66 20 87 69 64 16 68 6 60 91 84 27 69 20 63 84 8 28 97 89 68 55 41 16 90 5 73 71 59 35 69 31 49 21 37 79 79 21 45 87 74 5 7 64 22 10 21 62 93 5 46 77 38 31 71 71 67 72 84 19 90 93 63 29 28 1 84 46 89 51 21 17 96 22 64 35 10 53 63 16 94 92 71 34 52 41 5 72 61 68 15 77 96 85 88 23 66 87 27 58 12 85 12 44 8 67 82 48 70 57 37 4 55 21 75 79 95 73 55 38 60 59 36 48 3 77\n 24 62 79 85 30 40 9 86 4 4 30 27 6 24 21 10 15 53 92 6 22 50 80 19 10 68 98 1 95 89 18 3 78 37 21 50 60 94 27 11 69 57 93 29 53 20 24 21 68 52 52 73 8 86 53 81 41 89 69 4 75 15 72 87 20 96 23 57 88 89 64 40 83 95 67 57 59 98 54 90 52 66 4 60 58 86 99 53 4 93 10 69 7 39 95 94 58 9 77 64 8 55 12 49 64 56 87 60 9 85 60 6 7 59 94 3 58 14 79 94 14 70 27 70 7 3 12 33 81 19 25 5 21 87 51 49 39 42 69 97 69 2 54 5 64 36 66 32 59 64 67 89 25 9 44 65 95 24 75 2 46 9 9 23 84 28 46 6 59 51 60 83 37 74 63 33 11 24 68 50 73 61 33 67 75 23 15 83 15 10 6 50 90 28 74 19 93 38 47 49\n 45 39 29 22 77 15 44 54 25 35 95 47 46 56 21 17 71 5 38 80 77 55 47 17 10 19 1 72 63 48 55 58 40 90 18 97 40 54 9 28 99 44 19 80 7 39 45 35 75 52 20 89 43 20 46 12 58 87 11 96 77 85 81 8 36 3 61 63 47 68 86 62 87 19 6 63 9 88 53 98 56 93 18 82 89 46 21 91 32 59 60 10 24 14 62 76 92 80 41 67 5 11 9 10 40 40 69 58 56 87 6 3 94 42 47 42 27 23 89 2 57 37 15 35 30 19 71 38 60 3 36 48 10 52 2 98 94 90 8 52 33 5 99 37 32 66 78 90 50 70 49 57 87 53 8 21 52 67 91 42 3 41 73 63 18 27 77 7 55 83 89 60 44 58 56 25 99 62 26 3 7 87 50 71 49 14 14 37 79 45 27 91 43 97 60 12 36 59 21 64\n 69 87 97 43 24 99 51 14 15 24 82 7 75 82 2 98 46 59 10 80 55 68 91 33 79 58 79 54 13 70 26 34 9 7 74 73 70 92 97 60 60 21 16 64 94 94 16 56 96 20 32 31 44 38 14 17 43 59 17 11 91 61 63 89 62 23 27 13 52 47 4 6 4 45 22 94 34 31 82 58 46 49 46 64 48 46 28 99 41 85 74 35 74 99 92 7 15 65 27 15 62 70 77 39 43 73 50 95 69 85 64 80 27 36 87 5 72 8 30 30 69 12 33 84 20 8 97 42 57 35 60 19 53 72 5 51 88 96 32 33 16 19 97 17 81 19 77 18 32 66 7 91 74 64 63 45 23 90 10 40 35 45 44 59 34 83 20 63 53 79 48 66 90 40 10 14 29 94 41 86 49 60 20 44 46 48 59 87 6 76 53 33 92 27 34 16 34 31 73 66\n 98 82 98 30 49 66 7 49 50 82 76 5 83 70 58 67 90 96 32 39 73 80 69 21 80 76 19 24 77 66 32 12 77 29 82 97 30 61 95 53 80 33 2 87 86 97 17 61 98 62 87 15 95 39 4 58 62 95 47 34 91 92 94 40 17 22 81 6 33 51 6 48 43 15 81 65 56 78 48 72 70 16 11 90 82 5 56 50 55 33 83 52 36 70 97 69 60 75 76 20 73 82 43 18 90 3 56 16 77 29 17 91 90 81 11 6 25 81 34 16 86 37 52 31 94 38 3 95 7 2 12 19 50 10 44 23 69 96 65 41 80 59 43 61 17 33 59 10 10 78 50 91 58 46 15 34 28 36 44 51 46 31 24 57 18 25 26 22 53 52 74 17 30 24 28 59 72 28 12 28 49 97 81 59 24 87 39 61 59 32 61 13 62 54 81 51 23 29 65 74\n 99 76 36 34 38 23 23 62 58 28 61 26 70 73 37 46 7 92 62 56 89 68 31 55 37 75 74 76 81 93 28 61 30 7 43 42 39 52 59 68 73 75 33 94 30 32 38 39 65 4 74 31 31 71 86 60 82 2 17 36 62 21 16 14 65 68 30 42 46 49 99 93 22 55 12 42 28 2 54 46 13 67 17 20 53 96 27 34 62 96 78 62 67 19 39 85 92 4 19 54 84 98 46 25 93 44 73 33 75 38 3 86 91 17 7 59 15 66 81 97 6 76 65 30 55 88 21 12 86 6 94 99 44 95 43 75 66 35 26 93 93 36 88 52 7 4 39 93 6 12 9 39 16 98 70 6 30 97 9 54 92 49 76 93 62 10 60 22 89 60 69 38 67 24 53 98 93 70 99 34 97 93 35 31 4 19 59 45 32 33 67 27 81 17 91 6 36 59 50 56\n 57 34 22 91 98 63 54 50 82 96 5 91 16 26 38 14 49 19 36 91 93 74 94 96 9 68 23 60 36 70 63 36 83 18 41 50 83 75 22 8 81 16 99 62 79 24 33 71 50 19 53 71 8 8 57 46 74 75 22 60 6 31 33 15 93 71 79 57 60 18 26 75 40 54 58 75 3 38 50 97 28 88 33 15 47 44 49 89 53 95 25 30 1 67 46 56 10 81 95 5 50 32 4 73 9 90 22 35 42 45 94 83 18 80 60 15 78 86 67 23 98 5 94 25 72 73 32 56 79 70 30 24 39 52 21 92 81 31 9 30 38 47 21 5 42 52 48 57 27 62 96 78 25 41 16 77 1 11 29 23 97 36 31 85 63 2 5 98 49 60 10 16 38 91 86 40 35 71 44 13 33 71 27 87 85 80 66 9 27 4 10 33 32 20 50 60 17 15 14 7\n 22 71 89 32 71 99 42 60 50 80 93 56 26 27 21 1 3 27 80 32 45 45 56 74 37 15 90 40 92 59 75 63 84 82 3 7 43 9 31 37 89 68 17 82 9 63 36 30 49 59 94 59 26 6 27 35 44 66 73 29 24 51 91 35 48 9 14 96 18 14 13 30 46 66 9 35 46 85 71 48 55 62 62 45 36 95 38 71 53 3 38 95 8 25 26 26 47 18 83 38 62 69 22 92 78 94 2 85 91 63 52 18 10 33 47 58 93 48 47 37 52 90 51 50 90 54 58 88 85 29 49 39 4 81 79 65 35 65 75 45 18 67 66 28 65 28 39 87 1 13 29 87 72 10 63 43 12 62 62 94 32 13 77 2 13 7 33 96 25 69 33 22 26 98 36 32 10 55 60 4 29 51 35 51 44 67 65 54 20 60 29 20 89 80 81 47 41 5 79 54\n 86 24 81 27 38 53 2 35 38 89 23 64 37 28 59 5 35 1 93 84 38 23 21 75 89 76 76 8 33 85 92 69 4 33 78 28 70 9 44 21 59 62 46 53 16 50 72 23 55 18 48 67 94 86 97 12 80 91 81 19 32 7 39 54 63 92 38 95 53 18 42 82 27 62 1 86 19 52 9 95 28 79 54 1 69 94 62 16 77 70 47 56 78 22 67 97 12 15 3 33 32 18 85 44 73 76 19 83 49 77 74 11 32 5 77 25 19 31 65 8 63 98 62 15 94 35 42 81 85 3 30 76 63 19 90 39 45 64 46 57 29 55 20 95 61 7 95 74 71 13 57 62 52 74 63 66 71 70 6 14 96 64 15 54 98 80 34 55 89 13 52 60 47 44 87 88 71 49 98 4 10 13 81 18 2 69 41 62 70 87 24 16 66 63 10 58 54 72 43 49\n 4 18 34 63 17 35 59 29 30 46 40 57 89 37 11 37 26 20 46 39 7 25 52 85 38 45 11 89 55 52 40 76 82 72 10 93 7 88 60 63 45 43 88 40 47 3 87 30 20 61 36 4 24 78 67 56 82 76 64 47 99 48 85 22 25 95 1 24 59 38 84 26 77 48 31 5 20 3 60 39 86 23 15 8 15 43 35 41 19 75 73 51 20 20 33 65 33 52 85 65 24 93 37 1 75 74 44 34 74 99 70 20 52 97 34 76 95 71 33 73 35 3 92 57 61 28 9 53 27 41 22 58 31 54 33 63 93 57 67 67 36 43 86 28 40 9 75 62 69 21 60 54 64 92 37 75 88 68 50 56 24 97 27 56 55 65 38 67 27 6 26 16 66 66 5 84 21 45 78 24 97 30 84 42 32 96 32 44 35 26 23 61 70 19 26 23 47 27 75 69\n 37 83 89 90 63 20 46 72 94 85 75 68 1 47 27 9 48 33 86 22 83 56 29 41 96 30 86 71 43 32 71 2 8 9 46 47 65 38 50 33 69 45 65 3 99 71 21 93 40 39 26 63 55 15 4 21 45 80 87 66 13 83 47 69 13 27 41 28 20 34 90 7 9 76 95 28 62 62 52 51 21 91 51 13 23 45 43 41 86 51 30 20 92 11 57 80 11 81 43 45 81 17 13 93 89 34 27 78 46 87 21 82 82 20 94 34 92 96 59 73 8 98 35 51 70 9 63 61 53 30 3 33 57 34 27 35 37 50 35 69 26 71 11 23 49 40 8 14 11 99 94 42 47 41 98 97 47 43 79 68 29 79 76 51 86 88 43 49 68 30 45 1 10 1 17 17 85 16 84 36 71 33 57 66 8 62 69 67 75 86 52 40 95 14 31 86 15 66 5 71\n 49 28 78 67 93 63 64 23 3 24 62 70 99 51 36 32 93 75 73 78 78 18 5 55 10 53 77 82 20 49 39 92 80 82 95 98 99 41 73 94 80 72 11 46 81 60 56 27 39 14 98 29 26 52 59 57 40 33 58 15 95 44 26 9 37 78 85 29 96 20 86 50 71 56 14 10 17 64 67 8 55 35 59 1 64 46 23 57 41 2 35 77 43 45 52 31 82 35 77 54 47 90 73 26 47 68 57 2 41 88 52 27 61 87 3 45 66 31 36 81 84 58 26 99 14 73 95 91 72 9 73 95 35 50 13 77 41 88 8 34 37 24 71 37 94 78 50 7 62 24 46 17 19 11 98 99 62 55 80 51 67 95 11 99 86 95 83 92 2 66 67 45 20 48 64 99 15 27 83 45 75 41 86 57 88 65 41 19 28 14 23 81 86 90 72 23 16 21 23 34\n 58 7 12 29 55 62 44 9 90 38 13 63 11 26 57 12 73 93 41 45 6 92 61 35 84 23 78 30 27 66 71 79 85 70 59 91 94 40 94 51 2 86 1 21 10 61 29 78 26 34 42 87 68 82 13 2 40 30 87 6 51 79 70 75 88 9 9 90 87 54 35 56 98 8 33 39 56 51 72 82 53 38 31 60 34 52 86 43 81 63 26 46 79 97 66 34 87 65 47 70 24 80 68 47 78 31 71 83 4 82 63 70 40 89 33 73 76 11 90 91 68 70 50 27 98 72 73 5 76 77 41 52 74 52 93 16 80 19 89 35 12 51 39 89 74 73 50 57 82 40 79 76 69 14 87 59 84 43 6 40 40 51 17 41 81 4 89 60 21 94 70 52 98 64 16 42 7 59 31 51 16 22 29 64 58 22 44 76 38 53 69 35 33 2 94 77 20 34 85 20\n 8 66 50 43 52 7 92 5 12 13 26 7 14 40 85 57 60 9 29 27 36 3 62 59 98 43 23 48 12 56 30 34 60 2 11 28 82 17 39 39 4 62 89 66 85 62 9 76 1 34 93 47 97 53 20 87 49 51 17 13 82 15 11 56 8 30 97 96 14 41 7 54 98 42 42 62 24 53 71 80 69 62 70 59 43 38 26 62 81 74 35 43 85 37 6 45 9 79 41 35 55 36 39 68 39 43 83 12 52 16 2 23 6 46 61 1 32 82 97 39 7 44 54 29 84 41 42 22 45 46 86 33 58 55 39 70 93 91 19 42 16 38 68 42 93 81 56 93 58 57 77 70 20 20 16 89 20 24 15 23 70 28 50 25 72 43 6 92 5 78 97 53 66 8 53 82 79 55 42 90 18 4 99 38 94 59 71 20 14 81 77 70 35 70 1 16 5 14 54 19\n 34 42 79 18 98 19 26 56 49 57 49 44 8 44 25 25 95 47 87 85 32 22 99 68 50 87 1 20 94 83 16 84 56 38 58 68 38 34 95 43 50 16 41 44 30 38 76 84 65 78 23 5 64 33 63 85 13 45 24 58 26 49 84 29 11 62 48 24 42 33 90 65 16 90 30 38 60 41 14 46 3 73 10 8 83 7 80 42 63 65 26 61 40 5 41 85 88 82 33 13 32 60 10 54 26 16 94 22 81 91 15 37 72 64 1 96 66 33 73 88 59 16 19 80 2 18 17 29 14 95 59 52 50 86 12 46 42 16 99 5 3 18 53 47 71 73 91 98 22 61 56 91 38 7 10 54 73 84 94 11 22 24 42 22 10 36 90 43 57 41 88 24 50 9 82 88 10 54 35 7 99 71 4 94 51 1 42 42 5 89 90 15 47 94 65 44 2 53 14 19\n 70 74 46 5 33 3 19 53 98 61 37 60 41 14 79 49 88 70 80 76 5 20 36 64 42 8 36 66 18 98 87 78 53 64 78 99 85 13 80 76 59 2 64 94 64 58 70 53 41 40 37 23 56 60 65 50 26 65 18 65 91 11 29 87 75 82 37 22 57 8 29 93 12 45 39 63 46 89 35 35 13 21 30 57 34 71 40 58 62 13 87 56 45 57 68 81 28 7 94 39 7 25 76 45 49 51 84 76 71 61 94 27 93 35 56 32 83 7 10 44 40 40 17 35 93 70 31 55 31 51 39 39 82 38 52 93 43 80 57 88 69 20 83 79 23 62 30 94 36 6 4 71 51 2 37 44 96 19 76 65 17 50 44 51 3 65 9 25 22 84 72 54 72 3 7 20 77 36 29 87 30 3 17 42 88 26 89 98 91 90 37 82 78 42 63 33 98 37 46 84\n 14 74 37 63 95 20 36 51 9 31 64 6 51 81 66 24 59 50 1 49 27 42 54 48 48 64 24 13 42 52 34 14 46 33 10 37 34 78 86 44 98 36 63 58 91 42 15 45 52 68 84 92 12 57 13 28 89 21 4 99 19 70 79 51 34 5 94 11 49 84 4 69 76 16 32 10 80 70 78 69 97 78 98 90 29 62 65 41 64 77 13 47 18 18 9 30 60 90 59 6 65 64 18 30 85 29 37 3 53 26 32 44 20 19 71 28 82 40 47 24 31 45 65 96 14 16 86 86 93 32 33 1 32 13 63 47 16 24 13 80 54 23 47 11 67 50 9 82 13 40 17 10 98 94 34 37 68 38 52 26 74 91 59 30 5 95 84 16 62 85 98 34 97 6 45 53 57 81 91 47 28 80 93 80 46 57 43 99 12 81 35 81 36 38 72 86 45 43 56 71\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j20_m10.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 587595453 1582 1448\nprocessing times :\n 74 21 58 4 21 28 58 83 31 61 94 44 97 94 66 6 37 22 99 83\n 28 3 27 61 34 76 64 87 54 98 76 41 70 43 42 79 88 15 49 72\n 89 52 56 13 7 32 32 98 46 60 23 87 7 36 26 85 7 34 36 48\n 60 88 26 58 76 98 29 47 79 26 19 48 95 78 77 90 24 10 85 55\n 54 66 12 57 70 82 99 84 16 41 23 11 68 58 30 5 5 39 58 31\n 92 11 54 97 57 53 65 77 51 36 53 19 54 86 40 56 79 74 24 3\n 9 8 88 72 27 22 50 2 49 82 93 96 43 13 60 11 37 91 84 67\n 4 18 25 28 95 51 84 18 6 90 69 61 57 5 75 4 38 28 4 80\n 25 15 91 49 56 10 62 70 76 99 58 83 84 64 74 14 18 48 96 86\n 15 84 8 30 95 79 9 91 76 26 42 66 70 91 67 3 98 4 71 62\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 1401007982 1659 1479\nprocessing times :\n 80 13 64 77 17 78 82 4 72 93 68 25 67 80 43 93 21 33 14 30\n 59 83 85 85 70 35 2 76 46 72 69 46 3 57 71 77 33 49 59 82\n 59 70 76 10 65 19 77 86 21 75 96 3 50 57 66 84 98 55 70 32\n 31 64 11 9 32 58 98 95 25 4 45 60 87 31 1 96 22 95 73 77\n 30 88 14 22 93 48 10 7 14 91 5 43 30 79 39 34 77 81 11 10\n 53 19 99 62 88 93 34 72 42 65 39 79 9 26 72 29 36 48 57 95\n 93 79 88 77 94 39 74 46 17 30 62 77 43 98 48 14 45 25 98 30\n 90 92 35 13 75 55 80 67 3 93 54 67 25 77 38 98 96 20 15 36\n 65 97 27 25 61 24 97 61 75 92 73 21 29 3 96 51 26 44 56 31\n 64 38 44 46 66 31 48 27 82 51 90 63 85 36 69 67 81 18 81 72\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 873136276 1496 1407\nprocessing times :\n 49 49 15 18 65 55 1 79 10 37 77 80 79 84 93 21 85 64 46 35\n 3 53 59 7 65 58 24 55 26 40 89 94 51 74 54 86 22 83 19 44\n 60 88 15 26 11 16 55 59 81 53 92 23 55 79 13 89 2 17 97 41\n 12 47 46 17 43 16 91 94 73 89 12 58 25 24 55 1 67 3 1 71\n 75 19 60 87 27 48 72 88 48 59 74 86 49 94 15 95 41 94 15 71\n 31 61 47 32 34 69 32 1 1 80 19 57 98 37 31 51 66 38 62 72\n 70 78 41 9 47 94 26 65 17 42 59 80 7 75 63 96 7 10 47 38\n 20 78 38 26 64 62 11 38 68 37 74 9 65 16 38 85 50 62 39 97\n 88 30 34 33 21 7 94 10 73 85 82 62 99 67 61 10 4 70 31 49\n 9 41 22 34 83 55 3 8 75 30 57 65 89 60 90 84 74 17 2 19\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 268827376 1378 1308\nprocessing times :\n 94 43 6 47 45 51 73 49 31 58 19 36 54 75 7 5 82 20 31 32\n 3 18 43 41 83 62 27 75 52 58 18 1 61 67 55 72 16 12 87 21\n 39 23 28 31 86 19 85 90 77 4 85 81 9 52 67 77 45 7 21 26\n 1 92 83 43 3 3 51 5 38 37 44 66 31 8 79 42 85 92 89 29\n 63 96 50 12 15 11 33 7 4 58 27 7 7 54 31 94 25 8 61 51\n 86 36 19 71 8 77 8 6 40 39 24 82 69 82 39 52 85 48 22 57\n 44 25 85 86 73 58 95 13 50 39 24 55 58 79 42 98 44 16 13 74\n 19 82 12 70 6 64 3 4 29 43 40 77 88 74 13 13 17 45 2 22\n 55 46 68 15 55 74 42 40 88 68 67 67 8 13 74 47 3 95 36 46\n 67 66 66 32 8 30 92 40 13 79 19 29 27 18 42 86 30 41 27 50\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 1634173168 1419 1325\nprocessing times :\n 64 96 13 9 17 19 52 1 54 86 90 26 16 39 51 4 18 35 65 5\n 48 6 34 22 12 78 87 24 87 10 46 16 11 73 24 16 68 14 92 93\n 30 94 52 49 32 61 30 6 33 33 42 87 55 13 39 20 9 57 83 2\n 84 24 84 16 87 22 51 27 87 87 34 99 37 14 59 13 17 33 31 18\n 9 1 66 57 90 61 90 60 40 38 25 15 89 5 81 16 28 58 98 90\n 93 44 2 87 93 23 92 51 5 32 69 92 21 77 95 17 47 1 13 73\n 71 34 40 57 29 78 99 88 40 40 35 57 56 65 63 48 24 40 20 21\n 72 65 20 67 61 69 19 63 50 68 7 93 58 31 97 89 5 98 41 81\n 33 95 7 34 6 34 62 97 7 18 8 39 86 58 35 12 50 44 81 89\n 85 47 54 31 31 83 28 70 49 27 40 37 55 59 46 25 34 84 72 32\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 691823909 1397 1290\nprocessing times :\n 47 77 66 13 77 20 29 11 85 98 36 92 99 65 34 35 42 28 28 5\n 80 46 37 86 85 67 22 67 20 1 39 25 1 41 74 39 2 20 3 29\n 51 79 35 63 18 67 73 2 23 59 46 12 17 87 35 27 71 11 97 83\n 63 22 47 46 72 16 35 2 22 50 58 46 19 82 69 14 94 39 62 27\n 60 20 13 64 67 25 39 40 72 28 36 60 2 8 33 85 51 6 5 72\n 70 96 56 22 44 83 66 56 27 52 46 83 76 25 28 26 98 64 66 15\n 39 75 66 89 56 42 90 77 76 43 14 3 57 98 47 35 58 6 95 9\n 33 1 59 85 1 85 65 47 13 12 23 21 89 51 34 62 6 22 75 22\n 5 37 72 6 90 71 47 60 93 17 65 12 97 29 41 3 46 33 55 10\n 9 14 37 54 14 53 27 64 25 79 30 33 5 96 1 51 42 78 70 91\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 73807235 1484 1388\nprocessing times :\n 64 44 58 7 69 12 5 69 46 23 95 24 58 88 46 65 31 84 4 73\n 43 97 49 2 54 12 31 52 29 98 46 83 78 52 63 66 45 49 21 13\n 9 87 3 15 55 5 8 94 60 18 20 65 50 76 75 7 82 49 3 56\n 38 85 29 26 23 28 19 10 72 33 21 79 55 69 38 15 58 36 11 98\n 2 74 16 21 10 98 74 84 55 19 20 37 90 76 10 81 27 52 21 1\n 79 18 99 75 47 96 6 22 3 29 12 53 42 61 49 56 9 6 54 57\n 16 95 26 25 71 50 38 15 85 20 25 67 7 12 50 8 82 5 9 41\n 85 77 74 17 38 42 20 68 93 15 28 91 32 56 70 51 9 94 63 33\n 89 6 41 22 68 83 79 69 44 64 77 46 76 64 25 55 30 89 96 71\n 69 88 24 41 53 8 58 19 50 21 43 18 74 50 20 81 98 92 21 83\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 1273398721 1538 1363\nprocessing times :\n 9 19 86 38 71 82 12 20 37 22 97 85 93 33 69 70 29 48 28 76\n 91 54 71 36 13 44 27 23 95 15 25 88 46 5 38 74 21 36 21 4\n 96 78 7 72 80 38 17 98 88 78 80 54 73 83 15 5 27 20 75 24\n 73 88 17 24 53 86 10 30 71 5 11 97 10 84 58 47 69 80 49 74\n 37 94 51 1 9 16 89 2 80 38 94 93 89 95 95 63 17 98 2 19\n 28 58 52 11 21 97 49 55 16 4 82 60 5 52 42 61 87 89 76 46\n 32 18 3 60 34 69 47 95 92 70 71 73 58 17 26 39 60 72 93 27\n 27 63 59 76 97 85 57 49 60 30 70 1 23 18 42 96 2 52 49 82\n 4 67 77 24 68 37 28 65 93 68 18 6 49 67 93 3 10 80 44 26\n 83 4 50 74 14 8 67 18 60 3 43 31 59 69 13 46 53 27 28 63\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 2065119309 1593 1472\nprocessing times :\n 39 16 84 51 19 57 33 1 23 39 27 37 37 1 82 24 28 98 74 36\n 9 19 71 7 23 7 65 56 37 87 43 4 92 75 86 26 17 7 80 24\n 72 13 49 37 89 37 58 4 13 48 4 43 18 9 81 66 82 21 60 26\n 93 77 20 1 60 36 85 18 97 24 60 28 94 34 61 10 4 83 91 38\n 8 83 29 87 77 15 26 97 44 85 22 17 47 30 10 84 13 26 16 48\n 75 70 16 72 85 94 49 40 64 98 46 18 47 2 77 74 77 32 65 91\n 16 98 85 63 10 14 82 39 23 29 30 99 34 16 34 28 69 85 50 58\n 98 49 46 66 63 88 41 13 43 54 69 97 10 51 95 51 92 71 98 33\n 65 93 14 73 97 17 91 71 59 45 45 21 98 64 50 74 77 32 70 95\n 21 98 61 78 6 34 53 63 3 50 29 29 20 68 84 29 75 85 98 68\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 10 1672900551 1591 1356\nprocessing times :\n 74 26 84 41 3 46 39 90 62 63 74 4 37 75 72 30 43 95 41 97\n 70 92 36 70 37 36 42 34 29 80 91 56 71 14 31 75 80 73 32 56\n 84 20 64 44 69 63 94 86 66 97 25 90 12 62 83 32 12 38 22 92\n 63 61 46 6 83 49 78 84 97 56 76 9 38 21 80 47 24 95 80 65\n 72 91 21 70 12 67 65 90 47 82 62 3 84 30 91 5 11 41 14 28\n 78 58 53 17 36 3 83 91 73 81 74 2 31 37 78 74 51 41 78 26\n 33 70 10 45 70 2 92 50 54 64 44 4 99 43 43 11 60 53 45 63\n 87 20 71 95 71 99 79 19 41 74 8 55 87 87 37 52 36 6 42 30\n 3 86 3 89 57 27 28 88 48 26 58 6 33 3 25 61 93 69 53 47\n 28 36 39 63 66 44 18 67 17 84 9 33 80 27 42 60 96 81 31 88\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j20_m20.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 479340445 2297 1911\nprocessing times :\n 50 90 39 34 66 81 27 48 46 68 48 92 78 84 93 39 43 1 65 87\n 78 56 9 43 84 73 66 38 83 57 97 52 77 13 12 2 65 93 39 1\n 36 43 10 19 55 48 85 70 82 39 91 82 85 17 6 54 87 85 4 72\n 85 88 60 98 4 99 53 21 33 53 63 18 45 29 43 41 80 4 31 19\n 9 92 98 44 51 8 31 15 47 31 80 83 20 84 69 49 93 39 13 88\n 75 64 96 95 22 41 26 33 68 9 81 28 61 69 37 57 36 80 96 74\n 46 94 6 19 20 51 85 92 43 75 70 70 36 31 76 63 89 46 25 88\n 73 3 56 73 80 82 36 98 90 46 10 46 65 83 75 47 61 28 59 22\n 71 49 36 87 8 25 76 73 80 6 6 33 79 10 93 65 26 73 42 18\n 7 40 33 64 5 25 89 95 58 83 28 35 74 5 6 9 3 2 35 41\n 49 49 15 18 65 55 1 79 10 37 77 80 79 84 93 21 85 64 46 35\n 3 53 59 7 65 58 24 55 26 40 89 94 51 74 54 86 22 83 19 44\n 60 88 15 26 11 16 55 59 81 53 92 23 55 79 13 89 2 17 97 41\n 12 47 46 17 43 16 91 94 73 89 12 58 25 24 55 1 67 3 1 71\n 75 19 60 87 27 48 72 88 48 59 74 86 49 94 15 95 41 94 15 71\n 31 61 47 32 34 69 32 1 1 80 19 57 98 37 31 51 66 38 62 72\n 70 78 41 9 47 94 26 65 17 42 59 80 7 75 63 96 7 10 47 38\n 20 78 38 26 64 62 11 38 68 37 74 9 65 16 38 85 50 62 39 97\n 88 30 34 33 21 7 94 10 73 85 82 62 99 67 61 10 4 70 31 49\n 9 41 22 34 83 55 3 8 75 30 57 65 89 60 90 84 74 17 2 19\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 268827376 2100 1711\nprocessing times :\n 94 43 6 47 45 51 73 49 31 58 19 36 54 75 7 5 82 20 31 32\n 3 18 43 41 83 62 27 75 52 58 18 1 61 67 55 72 16 12 87 21\n 39 23 28 31 86 19 85 90 77 4 85 81 9 52 67 77 45 7 21 26\n 1 92 83 43 3 3 51 5 38 37 44 66 31 8 79 42 85 92 89 29\n 63 96 50 12 15 11 33 7 4 58 27 7 7 54 31 94 25 8 61 51\n 86 36 19 71 8 77 8 6 40 39 24 82 69 82 39 52 85 48 22 57\n 44 25 85 86 73 58 95 13 50 39 24 55 58 79 42 98 44 16 13 74\n 19 82 12 70 6 64 3 4 29 43 40 77 88 74 13 13 17 45 2 22\n 55 46 68 15 55 74 42 40 88 68 67 67 8 13 74 47 3 95 36 46\n 67 66 66 32 8 30 92 40 13 79 19 29 27 18 42 86 30 41 27 50\n 98 79 44 90 22 72 84 42 46 72 98 12 14 6 70 1 41 60 51 82\n 30 63 88 79 44 54 12 15 3 89 84 23 4 32 60 70 20 43 2 52\n 21 18 98 59 17 29 42 19 17 49 71 25 22 84 50 46 60 31 64 53\n 63 20 70 12 1 75 72 79 48 77 16 60 47 67 45 67 35 55 26 32\n 75 56 87 52 77 78 93 65 21 35 1 15 52 94 10 61 8 79 40 29\n 20 50 37 68 23 64 15 10 20 15 19 92 63 69 15 94 94 54 45 51\n 57 28 27 51 42 95 94 35 26 42 31 26 14 75 6 86 32 92 71 63\n 73 11 38 53 79 40 56 60 25 54 78 78 53 39 50 64 67 15 24 74\n 71 18 93 74 30 86 50 12 6 80 96 10 95 17 98 29 13 64 56 81\n 38 4 40 98 22 8 31 41 25 91 95 83 38 93 62 87 27 33 58 26\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 1958948863 2326 1844\nprocessing times :\n 46 52 79 45 97 10 44 24 85 75 66 49 95 61 19 47 84 13 11 19\n 98 2 85 44 7 73 19 69 12 73 85 23 53 16 88 8 26 42 58 63\n 7 2 44 38 24 76 85 61 32 90 61 87 51 25 73 93 28 90 94 59\n 64 2 16 35 53 40 81 26 85 4 4 10 63 96 55 71 66 94 7 15\n 11 99 37 50 56 69 22 56 67 63 96 74 4 42 40 30 93 36 25 87\n 3 1 58 85 33 71 58 56 64 43 48 69 96 35 82 53 64 11 61 36\n 53 87 88 10 32 38 25 24 90 7 11 49 2 76 17 32 39 9 83 69\n 67 28 88 23 91 71 3 26 41 96 51 24 21 57 69 51 50 51 21 19\n 63 91 11 6 31 63 36 39 57 47 56 65 59 4 10 12 62 43 49 54\n 87 29 2 18 75 39 77 69 15 78 68 37 22 41 92 67 24 87 91 31\n 37 16 42 47 94 14 94 34 72 36 88 51 41 71 94 99 11 97 44 77\n 69 91 38 25 87 7 66 54 86 49 3 48 44 93 37 82 31 59 78 33\n 36 3 58 10 98 6 44 62 24 94 79 93 68 75 37 44 34 39 76 62\n 74 28 78 43 98 83 91 27 6 82 60 44 43 76 99 66 11 35 52 8\n 40 62 25 24 30 1 73 27 16 91 33 11 99 2 60 90 36 62 15 3\n 83 87 38 38 86 67 23 19 97 78 66 67 7 23 67 8 77 71 85 29\n 49 3 94 76 95 48 4 37 82 57 61 6 97 5 27 95 46 92 46 52\n 8 11 7 54 72 57 85 22 87 65 22 29 99 25 98 55 80 82 33 68\n 47 74 26 61 95 55 11 42 72 14 8 98 90 36 75 69 26 24 55 98\n 86 30 92 94 66 47 3 41 41 47 89 28 39 80 47 57 74 38 59 5\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 918272953 2223 1810\nprocessing times :\n 74 15 51 4 36 61 65 25 55 70 18 81 22 3 48 74 82 19 84 83\n 60 62 9 59 28 61 81 53 86 77 19 67 52 17 80 11 91 61 55 2\n 98 79 24 25 57 38 81 50 49 19 14 59 36 5 46 62 98 4 39 90\n 54 41 7 98 75 24 57 32 56 8 52 63 97 95 55 19 91 62 29 56\n 85 65 90 43 61 39 82 95 94 58 64 41 36 26 98 39 5 87 87 31\n 31 73 51 29 29 25 44 64 85 92 23 26 2 36 94 53 72 79 58 91\n 14 32 43 30 92 64 72 16 38 91 61 10 10 72 29 28 64 61 42 80\n 92 39 99 47 20 84 32 66 85 79 83 3 44 34 79 51 29 40 63 40\n 28 70 27 4 60 55 92 55 49 81 19 8 36 32 79 84 52 61 92 31\n 51 6 75 81 35 34 22 62 90 65 8 57 14 19 28 17 6 49 79 76\n 64 96 13 9 17 19 52 1 54 86 90 26 16 39 51 4 18 35 65 5\n 48 6 34 22 12 78 87 24 87 10 46 16 11 73 24 16 68 14 92 93\n 30 94 52 49 32 61 30 6 33 33 42 87 55 13 39 20 9 57 83 2\n 84 24 84 16 87 22 51 27 87 87 34 99 37 14 59 13 17 33 31 18\n 9 1 66 57 90 61 90 60 40 38 25 15 89 5 81 16 28 58 98 90\n 93 44 2 87 93 23 92 51 5 32 69 92 21 77 95 17 47 1 13 73\n 71 34 40 57 29 78 99 88 40 40 35 57 56 65 63 48 24 40 20 21\n 72 65 20 67 61 69 19 63 50 68 7 93 58 31 97 89 5 98 41 81\n 33 95 7 34 6 34 62 97 7 18 8 39 86 58 35 12 50 44 81 89\n 85 47 54 31 31 83 28 70 49 27 40 37 55 59 46 25 34 84 72 32\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 555010963 2291 1899\nprocessing times :\n 72 47 52 40 49 86 75 26 37 29 34 86 96 36 55 41 97 74 55 61\n 72 45 73 94 76 28 58 98 65 7 77 1 75 46 61 93 79 23 71 46\n 79 55 95 46 59 89 16 40 28 51 80 95 41 18 14 65 26 5 7 75\n 95 67 93 90 73 63 25 36 7 26 86 50 80 48 12 57 34 4 99 20\n 1 83 17 69 72 61 67 83 89 99 5 47 84 76 68 36 30 38 62 61\n 90 30 88 69 51 7 26 5 1 90 40 78 68 31 91 23 55 14 44 22\n 37 32 42 3 5 79 33 79 56 96 57 23 19 24 25 73 69 24 19 5\n 92 82 95 18 85 27 92 77 68 46 57 61 4 58 94 50 31 25 34 80\n 94 82 24 98 74 98 93 80 25 99 19 34 12 55 71 21 5 61 37 22\n 15 50 27 12 59 97 38 83 84 54 79 51 93 95 66 12 80 20 28 86\n 8 35 46 25 41 50 24 46 1 16 65 81 9 82 26 38 77 96 65 43\n 62 44 89 20 21 72 96 73 34 10 99 46 66 42 33 70 95 57 40 19\n 89 99 23 34 68 23 31 14 77 97 11 60 21 25 56 86 11 2 77 98\n 96 47 39 43 45 13 95 89 27 71 43 24 3 22 76 38 82 94 25 72\n 89 93 74 2 54 60 57 21 65 70 27 93 8 35 9 99 60 38 43 14\n 54 68 26 47 51 44 21 34 61 52 73 45 45 3 68 46 60 8 6 70\n 46 88 61 6 33 17 21 27 57 4 14 86 72 10 39 19 71 61 72 94\n 94 91 88 56 94 13 33 68 27 74 81 11 74 27 51 36 58 39 48 46\n 40 58 85 69 67 41 6 24 65 20 12 9 4 70 98 10 87 35 90 61\n 28 23 59 85 4 14 53 14 70 76 41 50 88 58 29 66 19 64 77 25\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 2010851491 2226 1875\nprocessing times :\n 66 41 74 62 70 30 66 11 51 43 32 23 20 1 54 55 65 22 99 97\n 21 63 45 70 41 6 70 33 97 32 28 54 63 16 12 2 50 48 34 75\n 45 2 39 4 46 11 66 59 28 74 93 95 48 71 30 22 3 22 82 35\n 56 14 88 41 4 52 17 95 15 85 12 11 24 71 46 59 16 33 53 22\n 49 44 76 88 45 52 31 66 17 68 99 78 87 45 78 51 87 4 45 9\n 39 12 45 34 11 71 53 28 93 61 61 78 13 49 15 31 93 83 20 1\n 13 36 6 22 44 65 87 50 96 51 48 89 69 83 22 26 29 67 70 59\n 34 18 4 65 58 35 86 34 49 88 42 79 25 18 75 45 54 19 80 15\n 22 56 63 56 79 82 92 19 45 32 11 59 22 14 88 82 82 71 8 13\n 53 71 98 99 54 20 62 18 81 60 1 93 8 92 60 87 11 24 11 98\n 40 62 8 13 87 40 27 44 41 70 10 94 25 10 36 87 37 86 76 70\n 17 92 90 58 19 97 80 28 67 59 9 92 7 19 82 60 60 58 74 70\n 72 33 71 68 94 82 46 78 37 69 7 34 69 18 98 8 58 86 77 50\n 50 82 16 17 68 65 92 37 47 70 66 30 7 37 5 52 86 36 29 4\n 99 53 52 9 8 50 62 14 21 88 7 85 62 10 61 92 47 77 37 96\n 50 4 20 19 58 22 56 92 59 34 17 39 59 7 59 2 70 72 90 56\n 26 50 4 8 60 60 80 38 51 25 97 73 46 82 92 42 65 12 34 23\n 99 48 41 40 76 89 42 90 61 25 27 60 79 50 15 65 80 67 70 94\n 61 55 2 55 78 27 13 20 38 75 23 61 37 43 69 2 44 25 12 31\n 1 54 94 63 91 27 55 74 77 77 81 29 91 20 99 27 30 85 5 4\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 1519833303 2273 1875\nprocessing times :\n 77 3 60 92 17 38 45 92 20 33 14 39 66 93 37 44 21 77 90 63\n 52 83 50 2 9 48 68 37 57 19 59 20 25 64 92 6 24 29 6 64\n 47 86 85 2 43 56 90 41 55 12 99 36 90 12 15 38 19 95 24 98\n 40 56 42 73 98 74 49 32 48 57 71 65 73 19 12 20 29 39 38 28\n 72 88 83 38 8 20 33 63 44 43 33 34 82 22 58 78 61 67 43 64\n 90 70 23 28 50 33 42 69 36 80 37 25 87 41 34 54 51 52 90 22\n 89 59 43 77 83 36 40 85 60 65 78 44 15 55 49 77 5 72 97 46\n 91 42 79 6 56 13 66 74 21 7 7 29 23 11 36 50 91 10 81 87\n 15 91 46 51 64 19 98 34 54 9 10 20 46 4 90 88 71 50 23 50\n 34 18 67 15 34 64 71 5 82 84 38 91 55 1 4 71 49 31 18 44\n 87 36 48 1 81 59 57 82 49 12 62 95 9 39 90 41 33 53 67 17\n 47 40 49 23 3 84 4 40 36 13 90 57 3 3 66 74 28 80 59 39\n 56 33 58 99 85 64 40 55 58 99 38 39 5 30 2 97 33 75 31 68\n 68 87 7 21 91 39 25 77 58 96 65 1 83 57 4 36 77 94 11 41\n 94 36 45 26 4 37 20 55 15 81 82 81 74 68 14 78 93 69 79 63\n 57 79 74 21 69 39 41 76 84 20 7 40 26 28 93 81 25 82 60 25\n 57 56 15 51 30 82 92 76 36 5 18 63 82 45 51 16 15 39 72 70\n 12 72 17 91 75 60 20 23 83 93 41 99 74 54 10 61 40 96 18 85\n 22 35 89 4 71 43 34 24 39 44 40 97 1 98 61 7 77 95 68 54\n 99 78 42 88 54 50 54 83 36 41 80 45 14 96 45 65 17 27 77 54\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 1748670931 2200 1880\nprocessing times :\n 74 45 23 20 6 21 83 47 42 54 88 92 42 70 13 23 30 45 96 71\n 63 31 40 47 21 8 14 60 64 59 16 66 77 38 41 79 49 68 62 47\n 8 75 82 34 68 61 55 19 47 2 83 28 31 37 84 17 10 33 57 4\n 21 7 73 24 59 62 23 76 35 2 60 62 67 4 13 12 91 43 82 83\n 14 7 95 49 23 67 86 68 75 11 18 57 57 75 69 33 68 34 19 15\n 19 41 6 6 44 28 68 44 29 85 56 53 23 81 3 16 40 53 62 45\n 71 1 99 44 47 30 70 35 29 99 96 46 58 95 14 24 54 25 2 66\n 50 4 96 12 57 70 76 88 4 77 56 58 94 78 47 63 78 53 78 37\n 24 63 60 99 84 92 34 45 85 88 46 69 30 94 58 65 53 86 72 41\n 54 6 15 98 88 31 12 31 48 74 80 26 51 50 7 34 20 55 64 27\n 77 22 15 46 51 26 45 59 24 13 50 86 12 60 78 79 64 56 35 57\n 67 98 98 47 65 65 58 13 33 53 2 10 34 41 77 40 82 80 98 89\n 20 6 45 67 22 13 60 31 72 68 49 64 3 18 19 30 57 83 9 1\n 72 90 94 90 36 6 28 86 20 44 62 37 65 55 44 48 68 58 70 97\n 34 85 40 99 97 24 55 34 60 80 44 83 56 88 37 27 58 3 46 39\n 17 92 35 54 5 49 97 75 15 89 25 8 75 50 28 34 28 63 59 97\n 23 21 26 20 52 73 92 62 53 82 84 41 2 77 50 31 83 33 71 29\n 91 75 53 59 6 68 30 58 12 93 26 13 65 79 38 52 90 58 28 88\n 1 6 71 16 97 31 32 71 14 92 86 53 61 55 15 96 50 4 55 17\n 26 83 66 61 54 25 62 16 30 62 67 36 70 31 30 7 13 41 44 76\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 1923497586 2237 1840\nprocessing times :\n 1 96 21 57 7 34 72 12 80 99 28 80 30 15 95 19 12 59 66 51\n 6 36 74 53 25 68 37 42 68 74 93 39 75 54 10 60 15 75 71 22\n 10 65 39 99 77 39 50 14 75 28 92 74 20 70 43 6 77 25 68 83\n 28 13 74 18 71 11 17 27 89 14 13 40 97 70 96 13 66 77 2 41\n 69 34 10 91 98 60 3 86 55 95 73 65 24 22 5 67 39 58 4 30\n 95 75 24 3 83 67 88 75 28 65 54 65 34 17 51 98 94 22 57 37\n 90 38 20 85 49 37 29 84 93 99 44 39 18 40 24 98 61 72 21 76\n 87 32 8 17 54 43 3 65 33 36 70 18 19 76 7 34 66 72 16 95\n 80 10 63 14 89 65 43 44 28 39 59 91 70 24 96 1 92 79 57 88\n 60 70 38 94 94 30 50 17 43 28 33 48 48 81 50 86 23 95 3 80\n 17 74 87 39 14 28 12 49 88 91 53 40 1 55 39 35 99 17 69 67\n 13 98 79 20 57 68 17 27 25 36 67 73 34 47 65 79 31 54 56 33\n 66 30 89 45 44 91 18 67 94 41 78 27 15 55 28 28 26 98 98 77\n 79 12 96 78 29 28 14 52 27 51 46 98 97 38 78 89 67 91 51 62\n 79 93 25 61 59 20 92 1 35 97 79 37 72 76 89 7 79 85 40 24\n 6 73 64 30 30 99 61 26 38 46 76 65 51 39 23 71 63 94 62 87\n 43 45 46 9 10 42 43 46 7 15 32 80 4 73 42 98 24 25 13 38\n 3 69 38 61 8 54 90 3 5 25 31 38 36 35 52 13 78 31 8 62\n 36 98 7 3 5 82 41 2 63 56 85 85 25 98 58 16 99 61 21 26\n 67 96 70 89 5 45 38 79 73 99 33 1 84 79 44 39 16 50 39 55\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 20 1829909967 2178 1900\nprocessing times :\n 55 56 21 77 83 43 11 64 59 37 96 27 9 63 82 31 27 67 82 65\n 74 41 10 36 69 1 21 72 37 54 88 65 97 71 13 90 88 39 46 89\n 99 82 14 14 63 67 16 46 28 91 69 34 9 7 43 62 29 70 28 62\n 34 67 16 83 64 32 43 67 37 79 31 41 3 11 71 21 26 98 39 73\n 59 33 71 49 22 6 68 14 36 17 30 83 94 53 30 74 24 47 76 28\n 20 35 25 81 19 4 42 58 18 19 73 14 44 13 11 55 91 51 42 47\n 94 43 68 77 42 75 17 85 54 83 30 52 89 54 74 86 27 22 24 11\n 12 8 15 21 75 84 29 15 26 83 38 32 13 10 23 28 42 68 78 39\n 76 4 45 25 23 77 3 20 49 35 29 59 14 94 11 17 80 70 20 25\n 12 78 58 13 22 53 92 7 62 94 8 81 5 24 98 85 75 57 37 96\n 97 44 93 11 74 69 60 95 83 97 37 86 61 68 87 19 12 39 85 6\n 50 71 27 86 24 58 20 12 61 57 34 64 43 94 37 13 28 2 82 10\n 5 87 66 33 2 32 43 16 96 22 17 75 31 62 76 30 8 34 35 73\n 76 5 59 52 16 14 3 1 24 47 19 76 13 67 7 7 14 99 5 11\n 84 21 4 37 72 86 17 96 38 43 13 81 12 57 62 87 90 94 94 81\n 4 24 88 53 7 35 45 45 43 31 58 88 52 99 87 47 32 24 99 22\n 75 39 38 72 26 50 83 15 71 13 94 16 28 17 95 65 84 93 98 65\n 79 35 97 68 93 29 94 14 84 29 35 13 51 49 40 11 98 61 19 53\n 18 85 7 2 93 20 50 95 3 30 44 97 13 7 72 49 83 75 63 47\n 99 52 21 41 69 88 80 83 4 99 59 47 92 11 73 31 70 15 57 19\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j20_m5.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 873654221 1278 1232\nprocessing times :\n 54 83 15 71 77 36 53 38 27 87 76 91 14 29 12 77 32 87 68 94\n 79 3 11 99 56 70 99 60 5 56 3 61 73 75 47 14 21 86 5 77\n 16 89 49 15 89 45 60 23 57 64 7 1 63 41 63 47 26 75 77 40\n 66 58 31 68 78 91 13 59 49 85 85 9 39 41 56 40 54 77 51 31\n 58 56 20 85 53 35 53 41 69 13 86 72 8 49 47 87 58 18 68 28\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 379008056 1359 1290\nprocessing times :\n 26 38 27 88 95 55 54 63 23 45 86 43 43 40 37 54 35 59 43 50\n 59 62 44 10 23 64 47 68 54 9 30 31 92 7 14 95 76 82 91 37\n 78 90 64 49 47 20 61 93 36 47 70 54 87 13 40 34 55 13 11 5\n 88 54 47 83 84 9 30 11 92 63 62 75 48 23 85 23 4 31 13 98\n 69 30 61 35 53 98 94 33 77 31 54 71 78 9 79 51 76 56 80 72\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 1866992158 1081 1073\nprocessing times :\n 77 94 9 57 29 79 55 73 65 86 25 39 76 24 38 5 91 29 22 27\n 39 31 46 18 93 58 85 58 97 10 79 93 2 87 17 18 10 50 8 26\n 14 21 15 10 85 46 42 18 36 2 44 89 6 3 1 43 81 57 76 59\n 11 2 36 30 89 10 88 22 31 9 43 91 26 3 75 99 63 83 70 84\n 83 13 84 46 20 33 74 42 33 71 32 48 42 99 7 54 8 73 30 75\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 216771124 1293 1268\nprocessing times :\n 53 19 99 62 88 93 34 72 42 65 39 79 9 26 72 29 36 48 57 95\n 93 79 88 77 94 39 74 46 17 30 62 77 43 98 48 14 45 25 98 30\n 90 92 35 13 75 55 80 67 3 93 54 67 25 77 38 98 96 20 15 36\n 65 97 27 25 61 24 97 61 75 92 73 21 29 3 96 51 26 44 56 31\n 64 38 44 46 66 31 48 27 82 51 90 63 85 36 69 67 81 18 81 72\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 495070989 1236 1198\nprocessing times :\n 61 86 16 42 14 92 67 77 46 41 78 3 72 95 53 59 34 66 42 63\n 27 92 8 65 34 6 42 39 2 7 85 32 14 74 59 95 48 37 59 4\n 42 93 32 30 16 95 58 12 95 21 74 38 4 31 62 39 97 57 9 54\n 13 47 6 70 19 97 41 1 57 60 62 14 90 76 12 89 37 35 91 69\n 55 48 56 84 22 51 43 50 62 61 10 87 99 40 91 64 62 53 33 16\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 402959317 1195 1180\nprocessing times :\n 71 27 55 90 11 18 42 64 73 95 22 53 32 5 94 12 41 85 75 38\n 13 11 73 43 27 33 57 42 71 3 11 49 8 3 47 58 23 79 99 23\n 61 25 52 72 89 75 60 28 94 95 18 73 40 61 68 75 37 13 65 7\n 21 8 5 8 58 59 85 35 84 97 93 60 99 29 94 41 51 87 97 11\n 91 13 7 95 20 69 45 44 29 32 94 84 60 49 49 65 85 52 8 58\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 1369363414 1239 1226\nprocessing times :\n 15 64 64 48 9 91 27 34 42 3 11 54 27 30 9 15 88 55 50 57\n 28 4 43 93 1 81 77 69 52 28 28 77 42 53 46 49 15 43 65 41\n 77 36 57 15 81 82 98 97 12 35 84 70 27 37 59 42 57 16 11 34\n 1 59 95 49 90 78 3 69 99 41 73 28 99 13 59 47 8 92 87 62\n 45 73 59 63 54 98 39 75 33 8 86 41 41 22 43 34 80 16 37 94\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 2021925980 1206 1170\nprocessing times :\n 34 20 57 47 62 40 74 94 9 62 86 13 78 46 83 52 13 70 40 60\n 5 48 80 43 34 2 87 68 28 84 30 35 42 39 85 34 36 9 96 84\n 86 35 5 93 74 12 40 95 80 6 92 14 83 49 36 38 43 89 94 33\n 28 39 55 21 25 88 59 40 90 18 33 10 59 92 15 77 31 85 85 99\n 8 91 45 55 75 18 59 86 45 89 11 54 38 41 64 98 83 36 61 19\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 573109518 1230 1206\nprocessing times :\n 37 36 1 4 64 74 32 67 73 7 78 64 98 60 89 49 2 79 79 53\n 59 16 90 3 76 74 22 30 89 61 39 15 69 57 9 13 71 2 34 49\n 65 94 96 47 35 34 84 3 60 34 70 57 8 74 13 37 87 71 89 57\n 70 3 43 14 26 83 26 65 47 94 75 30 1 71 46 87 78 76 75 55\n 94 98 63 83 19 79 54 78 29 8 38 97 61 10 37 16 78 96 9 91\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 20 5 88325120 1108 1082\nprocessing times :\n 27 92 75 94 18 41 37 58 56 20 2 39 91 81 33 14 88 22 36 65\n 79 23 66 5 15 51 2 81 12 40 59 32 16 87 78 41 43 94 1 93\n 22 93 62 53 30 34 27 30 54 77 24 47 39 66 41 46 24 23 68 50\n 93 22 64 81 94 97 54 82 11 91 23 32 26 22 12 23 34 87 59 2\n 38 84 62 10 11 93 57 81 10 40 62 49 90 34 11 81 51 21 39 27\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j50_m10.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 1958948863 3025 2907\nprocessing times :\n 46 52 79 45 97 10 44 24 85 75 66 49 95 61 19 47 84 13 11 19 98 2 85 44 7 73 19 69 12 73 85 23 53 16 88 8 26 42 58 63 7 2 44 38 24 76 85 61 32 90\n 61 87 51 25 73 93 28 90 94 59 64 2 16 35 53 40 81 26 85 4 4 10 63 96 55 71 66 94 7 15 11 99 37 50 56 69 22 56 67 63 96 74 4 42 40 30 93 36 25 87\n 3 1 58 85 33 71 58 56 64 43 48 69 96 35 82 53 64 11 61 36 53 87 88 10 32 38 25 24 90 7 11 49 2 76 17 32 39 9 83 69 67 28 88 23 91 71 3 26 41 96\n 51 24 21 57 69 51 50 51 21 19 63 91 11 6 31 63 36 39 57 47 56 65 59 4 10 12 62 43 49 54 87 29 2 18 75 39 77 69 15 78 68 37 22 41 92 67 24 87 91 31\n 37 16 42 47 94 14 94 34 72 36 88 51 41 71 94 99 11 97 44 77 69 91 38 25 87 7 66 54 86 49 3 48 44 93 37 82 31 59 78 33 36 3 58 10 98 6 44 62 24 94\n 79 93 68 75 37 44 34 39 76 62 74 28 78 43 98 83 91 27 6 82 60 44 43 76 99 66 11 35 52 8 40 62 25 24 30 1 73 27 16 91 33 11 99 2 60 90 36 62 15 3\n 83 87 38 38 86 67 23 19 97 78 66 67 7 23 67 8 77 71 85 29 49 3 94 76 95 48 4 37 82 57 61 6 97 5 27 95 46 92 46 52 8 11 7 54 72 57 85 22 87 65\n 22 29 99 25 98 55 80 82 33 68 47 74 26 61 95 55 11 42 72 14 8 98 90 36 75 69 26 24 55 98 86 30 92 94 66 47 3 41 41 47 89 28 39 80 47 57 74 38 59 5\n 27 92 75 94 18 41 37 58 56 20 2 39 91 81 33 14 88 22 36 65 79 23 66 5 15 51 2 81 12 40 59 32 16 87 78 41 43 94 1 93 22 93 62 53 30 34 27 30 54 77\n 24 47 39 66 41 46 24 23 68 50 93 22 64 81 94 97 54 82 11 91 23 32 26 22 12 23 34 87 59 2 38 84 62 10 11 93 57 81 10 40 62 49 90 34 11 81 51 21 39 27\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 575633267 2892 2821\nprocessing times :\n 12 72 18 85 42 76 13 82 35 33 76 19 94 93 64 82 60 8 66 56 40 11 12 20 61 72 52 62 85 67 67 68 18 10 1 92 66 22 95 59 79 25 43 51 69 27 33 76 12 19\n 13 64 7 60 75 75 63 87 93 73 5 18 75 20 30 99 19 70 55 11 78 66 92 57 91 56 1 17 61 51 3 72 72 21 2 36 42 59 12 31 72 39 99 9 68 27 22 60 28 66\n 82 52 72 81 61 36 10 62 11 46 42 32 39 44 95 10 96 55 67 86 75 58 10 65 9 22 56 34 98 82 65 68 49 98 36 51 19 68 24 35 8 9 69 73 49 29 36 10 9 1\n 20 77 63 28 77 34 96 88 20 26 4 30 40 18 36 98 24 70 66 15 96 29 74 39 16 72 92 9 10 45 32 9 46 83 63 58 77 26 88 78 79 37 13 39 75 60 58 2 70 9\n 91 33 5 51 30 20 26 53 91 40 52 55 9 33 32 17 77 30 37 79 68 31 17 7 19 19 62 3 99 94 62 24 2 99 7 93 1 27 20 97 81 23 75 16 21 47 68 41 54 58\n 25 61 58 52 81 33 64 14 67 3 32 78 55 26 79 92 57 90 68 73 57 55 19 47 86 26 96 45 4 17 9 60 23 54 42 30 78 43 80 43 7 27 23 55 66 90 63 38 65 82\n 47 77 47 57 2 77 45 69 19 70 97 61 61 15 16 82 44 17 37 51 23 67 34 45 42 23 56 59 80 18 18 67 23 41 98 48 85 29 80 43 93 28 98 73 5 6 88 36 20 24\n 77 21 8 36 49 86 50 60 26 7 11 76 33 74 68 10 2 54 58 82 14 9 10 48 90 89 3 20 24 67 90 19 72 59 94 84 59 43 81 38 62 85 85 84 71 31 39 40 41 40\n 6 63 56 63 75 56 22 89 29 33 46 96 52 43 60 87 46 85 84 54 74 19 82 19 58 6 85 82 2 16 75 52 13 1 43 85 73 79 91 51 1 46 3 26 15 22 18 8 20 32\n 6 11 27 71 4 73 16 63 85 92 57 90 49 75 15 64 44 10 78 80 92 18 70 22 22 78 6 86 94 45 57 80 96 94 5 28 50 52 49 31 66 30 11 14 45 32 31 6 95 95\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 655816003 2864 2801\nprocessing times :\n 66 46 25 30 17 40 17 20 73 5 60 3 91 34 81 58 48 71 57 5 8 19 78 2 1 78 8 14 46 98 50 88 28 66 43 23 93 52 1 77 54 45 56 54 57 23 18 88 38 72\n 55 63 71 21 74 65 52 91 12 22 12 26 97 30 30 12 94 46 20 73 58 10 77 27 33 53 23 2 65 35 7 54 43 87 56 4 29 35 37 53 10 90 95 85 2 36 85 5 3 45\n 65 35 49 2 95 14 67 8 62 25 2 40 68 75 72 5 5 10 33 56 89 54 31 1 61 25 11 7 88 65 74 16 87 57 89 85 46 54 23 23 96 79 70 33 50 18 65 87 18 15\n 57 72 48 6 10 98 55 71 19 28 31 79 69 11 4 12 71 62 2 95 35 82 57 7 24 62 70 89 87 21 54 16 72 31 24 94 18 83 36 73 67 74 75 93 16 74 70 16 81 93\n 58 66 5 69 38 93 59 56 26 96 60 18 74 93 12 56 36 71 38 96 84 84 65 17 78 45 83 53 60 60 9 7 51 85 66 6 3 93 88 40 85 92 15 51 55 19 58 84 4 23\n 38 23 13 1 10 76 49 2 81 43 51 71 29 44 26 27 27 56 21 76 88 9 33 6 40 64 5 5 7 5 76 63 35 94 65 25 6 87 60 33 67 81 93 98 9 94 49 27 62 90\n 5 13 36 54 76 40 67 31 35 48 85 41 82 95 15 24 77 6 79 36 18 21 34 42 74 46 1 88 29 95 67 41 98 31 25 70 62 45 59 68 22 81 44 80 88 25 93 61 1 97\n 26 40 84 84 74 39 65 15 71 92 44 27 93 2 55 44 55 23 25 1 51 12 47 98 41 18 44 72 88 60 29 99 2 17 79 6 29 89 4 70 10 79 64 92 42 79 56 94 26 93\n 66 41 74 62 70 30 66 11 51 43 32 23 20 1 54 55 65 22 99 97 21 63 45 70 41 6 70 33 97 32 28 54 63 16 12 2 50 48 34 75 45 2 39 4 46 11 66 59 28 74\n 93 95 48 71 30 22 3 22 82 35 56 14 88 41 4 52 17 95 15 85 12 11 24 71 46 59 16 33 53 22 49 44 76 88 45 52 31 66 17 68 99 78 87 45 78 51 87 4 45 9\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 1977864101 3064 2968\nprocessing times :\n 49 10 30 85 7 23 56 93 5 34 72 78 25 31 73 69 18 15 39 2 55 33 24 19 19 97 98 49 95 71 2 55 37 73 91 58 33 78 60 53 38 53 90 30 14 53 87 51 25 50\n 76 91 51 55 32 26 37 21 58 26 19 65 52 36 89 95 51 56 21 35 90 26 83 37 59 3 44 42 57 45 36 90 71 37 69 27 13 16 32 53 59 8 98 65 50 85 78 38 55 89\n 60 39 94 82 28 52 87 19 58 52 63 28 44 80 88 21 36 64 75 6 41 4 5 77 75 91 88 22 8 97 58 72 45 55 12 35 95 95 56 53 48 61 46 29 85 1 75 25 39 92\n 40 56 89 53 26 38 15 3 75 4 48 86 28 51 62 46 43 1 52 19 85 37 73 25 35 79 88 29 7 18 26 63 41 20 97 80 15 47 29 46 78 16 67 44 23 47 98 97 49 65\n 32 5 49 51 33 97 74 48 9 65 38 71 38 76 43 8 66 62 18 13 16 64 18 87 86 29 9 96 40 78 78 63 13 47 31 97 5 86 51 46 56 69 50 27 60 48 74 91 92 80\n 17 43 13 20 41 94 18 28 8 71 82 42 90 76 62 95 74 80 33 91 35 80 79 68 97 98 3 22 52 80 32 75 78 36 46 16 36 93 39 19 95 91 49 35 93 11 93 6 96 19\n 33 98 67 81 43 72 32 66 97 36 36 67 1 47 87 12 91 21 6 6 1 38 69 77 3 75 64 53 18 10 97 18 48 70 60 75 94 14 53 90 19 42 86 15 58 7 65 40 51 61\n 98 90 4 39 79 76 53 77 10 2 97 31 62 28 74 60 53 74 88 11 88 92 7 80 67 27 21 43 59 30 17 4 7 21 83 44 70 30 39 35 8 6 92 39 55 34 98 47 99 16\n 90 93 35 65 66 10 48 81 27 49 61 73 60 88 42 62 28 55 58 55 90 61 73 3 74 94 30 81 9 87 58 42 59 48 29 83 60 83 76 43 90 14 84 10 15 38 90 80 19 15\n 75 68 39 71 31 43 5 32 6 56 56 72 23 95 50 53 27 8 18 81 57 54 99 20 10 19 18 53 73 10 74 93 22 75 84 9 27 32 51 83 70 13 1 81 13 98 58 28 3 21\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 93805469 2986 2908\nprocessing times :\n 16 90 63 73 57 17 29 16 94 47 24 39 2 5 75 7 74 96 94 44 63 38 22 76 2 11 71 94 77 57 45 58 16 96 41 52 57 39 74 35 52 42 82 43 47 34 96 13 33 58\n 13 27 27 9 88 3 29 96 39 15 61 76 79 67 6 61 32 76 96 59 85 36 23 72 71 44 88 58 51 73 10 85 16 41 40 57 85 73 9 24 94 4 96 37 84 2 94 21 4 73\n 42 21 21 90 54 64 55 93 1 36 16 7 98 20 83 77 39 63 72 47 21 98 97 86 7 81 5 56 57 15 7 85 77 14 23 10 93 57 58 31 92 6 37 77 80 41 18 68 81 41\n 37 43 87 77 39 35 49 66 35 2 38 73 28 97 20 46 85 53 78 73 72 82 59 24 6 94 67 66 30 33 32 51 38 8 82 63 77 73 66 65 75 17 22 34 3 8 87 50 76 16\n 68 3 58 57 49 13 72 13 13 5 88 38 82 41 61 85 81 53 65 89 50 78 38 82 38 38 85 55 64 47 87 66 5 16 48 29 67 72 5 79 30 64 3 80 11 99 32 25 84 12\n 24 1 57 86 35 9 55 8 93 11 39 10 84 80 59 37 80 69 13 19 25 92 45 14 73 85 75 96 33 17 76 96 4 16 9 66 46 64 3 93 74 29 68 38 86 90 50 11 64 4\n 51 57 82 47 82 14 79 57 88 79 22 72 58 78 18 48 72 38 71 82 61 73 50 56 95 16 6 7 86 21 27 44 64 32 46 37 39 96 44 70 41 56 44 27 41 66 87 42 7 54\n 8 54 15 47 73 33 73 35 45 75 83 12 59 95 96 75 62 44 43 30 47 36 65 85 1 71 13 54 2 82 16 15 14 49 68 28 87 85 90 17 54 59 25 23 60 60 68 70 80 4\n 59 85 73 87 87 89 48 57 59 73 66 95 61 13 79 88 19 18 21 33 11 8 8 83 13 89 63 64 53 28 17 2 77 61 73 69 23 56 78 65 85 99 52 78 8 58 51 43 52 41\n 67 99 57 47 93 35 32 77 28 75 95 15 18 97 37 53 97 73 60 39 48 9 17 83 10 2 66 50 36 45 86 8 47 52 98 22 55 62 23 82 32 20 38 23 40 55 79 66 97 29\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 1803345551 3006 2941\nprocessing times :\n 65 4 10 87 31 52 35 89 28 45 24 68 94 71 70 2 83 85 97 65 64 38 54 26 40 75 59 38 40 89 64 84 47 62 74 38 79 57 8 46 27 28 62 34 18 63 74 26 28 78\n 55 99 12 40 7 8 14 68 4 63 27 61 65 7 14 16 3 31 56 67 74 59 81 43 57 11 32 21 73 75 46 34 50 47 22 81 42 4 49 24 54 29 87 38 19 65 23 77 71 90\n 87 72 33 50 77 83 89 90 26 93 8 86 39 13 59 99 98 76 52 43 79 64 4 19 45 80 15 43 37 49 36 33 83 28 46 71 59 15 50 53 51 56 76 48 11 35 88 59 51 13\n 38 19 37 75 8 63 91 38 92 25 19 42 89 80 11 84 33 42 51 18 56 83 49 14 1 23 72 24 63 15 33 93 5 78 33 91 56 99 29 15 54 46 2 90 96 93 3 53 97 51\n 38 90 23 59 15 72 63 48 94 12 63 46 60 72 33 50 25 14 20 50 32 87 42 70 92 10 75 57 30 45 91 20 32 9 72 11 5 17 66 17 92 10 93 36 40 74 99 86 29 70\n 22 63 63 38 53 73 37 68 38 10 74 27 84 65 40 97 82 98 50 23 66 56 30 27 36 19 28 66 70 79 21 26 81 61 19 91 43 34 85 73 82 15 65 42 48 28 25 84 37 88\n 34 88 4 98 83 76 89 22 23 70 69 30 11 89 79 29 52 68 14 99 4 3 4 33 98 44 34 13 78 15 25 35 16 37 69 82 13 51 48 53 13 46 39 1 72 28 20 90 84 38\n 99 59 6 45 6 27 31 95 91 94 21 72 65 41 9 56 33 98 11 51 7 94 43 47 77 89 53 34 79 85 4 12 99 80 42 89 85 46 4 58 17 98 71 81 26 80 70 49 24 41\n 81 51 80 55 52 64 2 59 88 11 68 16 75 94 43 23 5 53 76 60 51 96 50 38 28 8 70 51 77 83 71 41 60 25 38 97 13 5 58 22 17 51 52 15 1 99 62 72 45 90\n 50 99 94 1 73 58 1 8 41 97 67 1 58 73 62 9 88 6 34 5 59 16 13 80 54 96 48 72 96 91 49 92 3 45 28 37 51 96 88 83 24 58 21 25 12 85 58 48 37 3\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 49612559 3107 3062\nprocessing times :\n 29 28 63 73 99 55 79 82 2 45 45 41 26 87 52 10 42 72 59 45 54 71 44 49 78 7 57 10 63 73 91 22 63 98 92 91 28 86 76 36 29 5 77 81 73 65 72 61 32 61\n 39 38 12 83 98 31 37 48 59 28 91 88 51 62 99 43 7 10 77 35 28 98 17 75 82 89 48 60 26 52 65 10 27 25 6 96 16 57 98 38 66 91 70 83 49 7 54 25 6 87\n 19 6 72 73 43 3 47 34 28 32 7 29 89 84 33 95 64 9 44 23 45 68 88 96 56 43 11 95 94 99 56 3 2 23 75 17 46 83 98 30 23 77 12 12 15 70 78 13 22 90\n 98 38 80 84 28 15 46 67 78 39 85 93 22 22 36 67 7 83 78 68 75 7 65 23 32 13 38 51 79 50 25 83 6 16 36 16 43 66 79 40 8 71 77 31 83 31 76 9 45 76\n 20 79 35 67 65 20 30 23 85 55 32 45 94 84 48 56 46 90 73 2 8 62 49 86 97 34 2 19 66 23 1 26 47 10 75 39 18 57 95 70 11 42 9 61 81 75 94 31 48 88\n 58 44 53 11 92 50 37 57 14 64 63 16 9 97 86 87 77 20 60 83 72 29 3 27 33 3 41 61 63 52 69 97 45 4 72 19 66 35 43 72 28 46 73 12 74 41 59 42 47 23\n 59 66 35 61 70 17 98 40 46 88 93 11 33 65 15 67 41 1 90 8 16 12 86 71 53 13 32 64 53 51 58 95 6 93 47 22 83 4 17 17 86 16 59 43 1 18 87 27 94 57\n 59 60 72 54 97 71 43 92 71 53 28 97 55 91 33 12 12 36 73 78 7 3 4 87 84 16 12 84 2 34 9 98 83 98 70 3 76 16 49 27 20 24 61 48 49 34 97 92 62 81\n 76 72 23 74 99 74 71 27 81 75 47 90 17 59 91 27 69 29 79 95 20 88 54 46 46 82 50 10 53 69 25 2 29 51 12 65 85 48 73 1 4 46 80 72 96 47 22 9 90 58\n 77 34 66 3 52 3 51 89 78 62 40 8 32 37 14 80 10 43 87 27 85 36 11 27 9 16 57 87 58 25 52 92 67 1 69 37 93 20 21 53 37 98 68 74 7 64 24 85 31 51\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 1899802599 3039 2959\nprocessing times :\n 56 78 92 66 30 26 16 48 30 97 54 62 23 43 21 98 19 17 80 56 32 86 85 88 77 15 48 11 33 72 69 74 48 50 41 88 50 13 74 16 91 40 59 28 61 34 7 22 63 69\n 13 78 8 69 42 11 70 21 53 88 2 69 37 78 69 97 53 51 31 76 3 20 32 29 36 34 89 43 48 68 52 39 12 50 48 50 73 99 10 89 13 85 50 52 39 60 89 91 76 28\n 24 79 83 40 97 36 61 48 24 71 75 2 26 13 68 32 58 84 19 10 6 79 69 37 13 35 97 45 72 80 24 30 89 72 85 17 35 13 80 50 4 60 55 82 5 93 38 75 40 46\n 36 31 87 52 20 86 70 78 99 76 56 71 45 10 34 81 77 92 34 35 5 28 73 65 71 47 98 7 42 71 54 7 90 14 15 63 19 90 72 66 58 60 66 11 83 9 85 68 79 94\n 39 33 9 67 41 61 17 76 31 39 25 9 69 75 42 53 26 29 15 41 32 24 63 23 95 88 40 25 12 12 9 69 28 78 1 23 79 25 15 18 3 80 41 15 94 96 6 52 59 51\n 26 37 18 42 47 26 30 62 41 59 14 96 31 19 22 80 57 88 73 94 49 7 33 56 81 38 13 14 62 58 5 9 91 16 38 7 94 43 66 94 54 12 34 80 6 72 40 38 36 86\n 67 44 73 89 53 57 60 52 42 80 42 45 37 73 44 73 5 78 89 20 94 82 42 31 1 9 5 51 21 31 54 1 3 4 58 30 10 55 6 23 29 63 71 91 94 68 46 12 89 50\n 73 48 89 44 56 87 89 72 67 65 97 45 2 68 39 6 24 88 96 17 11 67 81 99 22 26 1 23 41 38 36 50 59 92 55 78 77 25 25 20 87 32 12 52 33 90 81 40 67 84\n 53 81 50 4 36 76 10 8 17 28 3 80 14 6 32 20 17 67 67 52 39 93 46 76 78 87 16 19 82 80 28 97 60 8 40 44 72 97 10 4 15 95 4 63 68 28 50 31 38 65\n 97 80 16 40 45 64 36 44 98 82 66 69 44 55 68 84 77 77 28 45 9 23 23 28 19 91 75 6 60 12 61 35 81 51 94 57 65 5 26 34 61 63 72 14 43 3 94 54 13 89\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 2013025619 2902 2795\nprocessing times :\n 68 40 43 72 87 59 67 89 84 43 92 90 23 20 97 57 33 7 69 56 16 41 7 74 54 67 15 85 83 42 29 64 3 9 35 24 72 70 47 78 60 11 60 5 24 52 39 14 65 99\n 69 96 54 37 35 19 10 88 61 95 18 49 69 86 28 6 40 88 94 78 43 31 54 80 11 27 3 32 2 49 27 81 18 83 84 49 64 20 52 42 51 66 95 18 37 70 22 87 67 15\n 1 37 91 59 2 44 29 37 30 20 19 79 41 79 49 21 97 86 15 57 76 14 57 80 93 31 66 30 82 11 71 94 35 71 76 76 26 31 58 31 98 26 92 11 72 46 20 38 57 5\n 19 65 35 89 41 15 99 19 74 63 92 29 47 80 7 43 89 9 99 38 76 52 48 55 17 63 92 77 31 44 76 18 7 40 47 73 41 70 86 8 63 77 91 24 19 63 72 17 46 66\n 10 76 75 29 10 86 62 26 1 62 89 2 62 96 99 91 85 42 7 4 23 74 83 41 63 99 55 37 23 1 84 46 31 93 79 32 71 60 42 24 51 98 64 85 31 11 95 58 57 28\n 76 40 96 54 91 90 41 72 37 38 64 98 36 20 3 41 93 44 3 19 66 55 66 68 1 5 59 64 1 5 11 46 10 56 25 95 12 48 11 45 25 62 12 67 17 59 30 73 34 27\n 50 87 77 88 80 75 41 84 24 27 52 73 75 23 52 97 40 50 95 34 2 76 26 48 16 20 86 62 54 50 26 4 4 59 24 14 49 35 78 77 72 10 87 24 26 46 40 86 40 8\n 39 11 96 74 22 22 50 6 95 83 70 1 8 94 65 70 61 80 82 23 51 92 25 23 40 69 42 13 17 27 74 7 25 73 81 84 40 28 86 17 66 33 20 84 23 73 25 87 2 15\n 77 30 88 21 29 12 2 95 24 20 66 82 45 4 22 81 56 85 3 82 94 72 96 55 3 63 65 20 4 95 20 57 38 46 76 10 79 7 12 60 85 73 18 75 77 71 83 63 52 66\n 30 71 57 83 34 31 11 50 22 7 82 34 5 62 3 68 35 79 10 60 67 10 87 25 24 4 36 44 22 8 49 97 8 9 18 34 54 42 70 59 8 29 6 42 33 67 7 64 7 60\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 10 578962478 3091 3046\nprocessing times :\n 18 77 73 91 96 10 58 70 42 21 11 88 91 78 70 53 51 96 27 47 30 37 63 61 73 80 5 82 49 11 79 78 57 47 91 92 94 33 52 12 37 47 39 4 50 90 58 46 14 84\n 97 49 33 48 68 36 66 6 54 16 7 35 64 18 8 61 41 65 71 34 35 92 70 65 76 71 81 32 27 95 49 51 65 17 91 23 17 19 28 70 67 40 81 54 52 38 6 8 31 98\n 14 17 31 37 85 84 7 54 40 95 97 44 4 46 10 63 76 23 95 73 78 46 40 34 92 42 56 4 63 93 72 63 62 30 91 96 53 19 40 14 16 66 54 54 64 86 31 99 10 2\n 74 29 77 14 30 14 48 1 4 71 54 30 42 43 33 32 12 68 8 82 27 59 20 60 76 44 29 68 24 46 94 79 68 49 85 87 17 99 76 81 52 24 57 8 36 67 57 66 5 69\n 75 43 70 11 64 88 94 9 29 58 90 78 63 34 71 49 69 97 10 43 22 16 31 22 62 14 11 46 85 59 73 22 70 52 70 45 45 37 2 90 2 40 70 93 44 71 83 13 3 99\n 27 98 62 17 35 71 94 58 77 29 61 41 47 2 16 41 59 27 18 33 1 99 3 15 45 82 20 11 90 65 73 71 26 97 50 43 7 78 27 50 70 65 96 27 66 18 96 66 82 23\n 69 28 95 38 89 19 6 52 70 4 81 1 36 30 13 90 30 66 28 36 38 48 97 56 92 93 81 24 38 39 33 7 75 43 92 44 35 2 96 28 13 67 61 71 20 54 53 75 58 74\n 65 21 60 72 4 85 47 80 71 26 73 36 38 13 66 82 2 76 29 90 36 32 84 78 94 45 14 72 3 18 58 87 30 73 71 5 77 60 6 61 23 29 2 67 69 38 37 80 51 34\n 89 41 16 7 84 53 56 71 40 17 33 3 51 76 2 63 84 55 3 82 46 58 24 57 59 86 39 55 69 36 98 82 44 70 67 74 61 38 87 35 37 98 26 49 12 52 49 92 43 75\n 83 3 99 87 60 92 75 53 30 59 95 85 63 21 78 72 87 52 39 93 22 82 21 65 81 59 73 74 33 53 47 69 11 31 69 67 3 21 29 28 45 2 53 36 5 79 76 32 87 4\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j50_m20.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 1539989115 3875 3480\nprocessing times :\n 52 95 42 75 44 57 89 53 84 62 91 14 95 89 4 95 2 97 68 20 33 51 98 8 85 86 73 4 40 98 12 59 44 46 2 41 28 83 28 21 80 71 4 60 34 55 53 96 37 37\n 63 99 69 70 53 21 10 31 80 18 5 18 17 71 90 93 14 49 52 7 78 57 41 75 98 93 33 75 68 33 60 82 24 99 4 97 24 50 55 91 46 58 17 47 82 6 15 91 74 42\n 82 21 79 95 46 23 40 95 87 37 24 24 65 62 19 67 66 6 65 59 2 67 82 90 30 63 5 93 53 85 81 73 34 74 13 78 35 20 16 48 12 11 80 9 24 76 32 35 66 48\n 16 26 46 66 76 31 36 8 37 21 3 76 67 5 47 72 66 56 95 49 47 26 81 56 76 66 36 53 26 52 29 36 68 21 71 61 71 69 28 86 27 41 86 55 17 62 96 59 53 93\n 63 55 59 35 21 59 78 25 30 38 78 79 58 44 38 76 70 72 85 8 10 84 42 67 20 24 75 23 33 60 20 75 83 26 92 29 39 14 74 66 86 10 27 8 7 97 84 56 61 9\n 94 34 89 62 47 66 76 15 18 54 24 55 96 10 12 96 53 92 77 6 91 14 41 30 85 17 23 60 76 39 85 10 65 15 55 41 28 93 88 27 77 81 19 76 55 67 65 8 18 56\n 79 21 93 32 8 45 37 78 26 98 17 25 21 28 68 24 62 89 60 64 38 90 87 1 99 34 9 22 74 14 14 84 75 37 32 29 32 89 12 47 19 97 7 12 43 89 14 33 56 57\n 22 6 24 55 48 57 78 5 50 83 70 21 71 58 36 50 31 86 29 30 93 49 83 89 44 38 62 45 22 85 39 98 56 68 84 77 67 53 46 24 52 96 2 88 33 27 49 78 82 65\n 80 13 64 77 17 78 82 4 72 93 68 25 67 80 43 93 21 33 14 30 59 83 85 85 70 35 2 76 46 72 69 46 3 57 71 77 33 49 59 82 59 70 76 10 65 19 77 86 21 75\n 96 3 50 57 66 84 98 55 70 32 31 64 11 9 32 58 98 95 25 4 45 60 87 31 1 96 22 95 73 77 30 88 14 22 93 48 10 7 14 91 5 43 30 79 39 34 77 81 11 10\n 53 19 99 62 88 93 34 72 42 65 39 79 9 26 72 29 36 48 57 95 93 79 88 77 94 39 74 46 17 30 62 77 43 98 48 14 45 25 98 30 90 92 35 13 75 55 80 67 3 93\n 54 67 25 77 38 98 96 20 15 36 65 97 27 25 61 24 97 61 75 92 73 21 29 3 96 51 26 44 56 31 64 38 44 46 66 31 48 27 82 51 90 63 85 36 69 67 81 18 81 72\n 71 90 59 82 22 88 35 49 78 69 76 2 14 3 22 26 44 1 4 16 55 43 87 35 76 98 78 81 48 25 81 27 84 59 98 14 32 95 30 13 68 19 57 65 13 63 26 96 53 94\n 27 93 49 63 65 34 10 56 51 97 52 46 16 50 96 85 61 76 30 90 42 88 37 43 88 91 14 63 65 74 71 8 39 95 82 17 38 69 17 24 66 75 52 59 4 73 56 19 39 51\n 95 53 54 22 84 54 2 80 84 66 25 16 79 90 51 29 29 90 83 83 19 95 87 12 34 23 44 30 82 83 42 56 89 38 96 10 3 53 97 11 65 47 76 22 17 14 11 69 91 53\n 3 80 78 32 53 43 85 19 48 49 66 22 37 51 82 59 88 77 19 32 52 9 96 23 64 22 37 3 52 44 11 21 85 6 40 68 30 35 58 31 11 11 6 59 64 65 23 80 75 63\n 92 62 11 83 87 66 98 42 23 45 52 6 3 64 55 97 83 42 81 92 68 46 56 88 50 13 23 13 49 18 50 94 71 64 31 21 2 63 58 36 64 52 8 94 51 36 82 30 17 21\n 80 38 55 34 85 44 47 66 19 66 61 60 98 82 79 71 28 74 27 33 13 9 12 51 16 49 83 48 13 78 96 77 68 88 77 76 73 92 72 87 66 98 40 31 75 45 98 90 4 23\n 61 86 16 42 14 92 67 77 46 41 78 3 72 95 53 59 34 66 42 63 27 92 8 65 34 6 42 39 2 7 85 32 14 74 59 95 48 37 59 4 42 93 32 30 16 95 58 12 95 21\n 74 38 4 31 62 39 97 57 9 54 13 47 6 70 19 97 41 1 57 60 62 14 90 76 12 89 37 35 91 69 55 48 56 84 22 51 43 50 62 61 10 87 99 40 91 64 62 53 33 16\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 691823909 3715 3424\nprocessing times :\n 47 77 66 13 77 20 29 11 85 98 36 92 99 65 34 35 42 28 28 5 80 46 37 86 85 67 22 67 20 1 39 25 1 41 74 39 2 20 3 29 51 79 35 63 18 67 73 2 23 59\n 46 12 17 87 35 27 71 11 97 83 63 22 47 46 72 16 35 2 22 50 58 46 19 82 69 14 94 39 62 27 60 20 13 64 67 25 39 40 72 28 36 60 2 8 33 85 51 6 5 72\n 70 96 56 22 44 83 66 56 27 52 46 83 76 25 28 26 98 64 66 15 39 75 66 89 56 42 90 77 76 43 14 3 57 98 47 35 58 6 95 9 33 1 59 85 1 85 65 47 13 12\n 23 21 89 51 34 62 6 22 75 22 5 37 72 6 90 71 47 60 93 17 65 12 97 29 41 3 46 33 55 10 9 14 37 54 14 53 27 64 25 79 30 33 5 96 1 51 42 78 70 91\n 53 66 41 79 58 57 17 66 42 66 16 19 42 80 9 48 62 65 70 45 3 98 11 2 64 77 85 12 18 75 83 2 2 29 81 94 38 56 92 77 31 65 59 89 66 92 15 50 39 26\n 61 18 82 96 68 7 65 95 30 84 23 75 71 60 21 76 37 65 78 37 71 60 59 18 94 55 53 58 47 65 29 26 6 13 4 38 64 47 7 2 46 30 58 77 86 9 39 18 22 61\n 77 74 69 8 84 81 37 26 10 60 72 89 49 47 47 90 6 87 10 34 52 72 77 94 44 80 88 94 39 75 35 35 92 17 74 77 45 70 5 33 80 31 3 27 80 10 38 86 51 39\n 25 96 32 37 19 42 86 49 55 92 85 94 22 30 93 83 95 1 16 75 43 80 42 78 9 56 35 96 71 97 53 51 58 8 56 93 96 56 36 81 72 33 37 90 96 11 66 64 27 37\n 15 71 11 98 77 50 39 14 66 41 1 9 40 94 60 5 44 45 38 20 67 57 4 24 12 63 26 27 8 7 33 21 79 6 64 10 86 84 82 25 27 41 35 44 9 80 13 79 58 73\n 54 1 54 10 35 27 57 90 91 64 90 59 54 43 69 13 27 81 40 66 93 61 63 27 13 43 88 61 95 39 44 4 57 11 50 34 77 19 42 35 56 53 95 78 18 31 63 96 11 83\n 72 79 76 84 35 84 62 47 26 74 30 14 74 42 93 89 19 84 22 60 42 7 50 56 25 70 84 73 70 17 3 96 45 81 33 16 86 67 19 5 12 94 10 55 98 45 77 30 87 18\n 57 4 35 86 50 63 17 11 99 22 76 98 35 18 82 96 7 43 79 39 58 32 12 84 1 41 20 78 69 76 16 68 17 82 58 2 34 28 35 35 86 26 29 49 27 60 51 13 19 56\n 65 89 18 14 60 78 56 3 79 15 48 9 72 41 83 27 73 80 16 34 42 65 57 88 78 62 19 60 60 58 29 40 22 3 27 48 89 31 5 59 2 14 43 47 48 4 12 19 28 66\n 55 71 5 34 24 18 84 39 76 19 95 98 48 15 62 70 7 37 59 61 66 26 70 70 85 51 32 35 46 80 11 23 48 30 28 65 78 77 32 61 68 98 26 12 94 4 15 94 19 52\n 99 76 88 99 82 1 14 15 13 38 84 53 23 52 66 4 98 83 40 32 50 75 65 27 30 98 55 91 47 32 61 63 14 56 28 11 40 9 60 17 49 12 44 56 44 40 81 75 55 44\n 26 97 65 27 77 43 4 77 66 38 1 48 20 95 39 13 9 2 5 36 57 21 49 19 78 44 98 55 62 27 86 4 71 63 93 18 70 5 21 48 13 53 70 42 73 42 72 89 1 26\n 72 47 52 40 49 86 75 26 37 29 34 86 96 36 55 41 97 74 55 61 72 45 73 94 76 28 58 98 65 7 77 1 75 46 61 93 79 23 71 46 79 55 95 46 59 89 16 40 28 51\n 80 95 41 18 14 65 26 5 7 75 95 67 93 90 73 63 25 36 7 26 86 50 80 48 12 57 34 4 99 20 1 83 17 69 72 61 67 83 89 99 5 47 84 76 68 36 30 38 62 61\n 90 30 88 69 51 7 26 5 1 90 40 78 68 31 91 23 55 14 44 22 37 32 42 3 5 79 33 79 56 96 57 23 19 24 25 73 69 24 19 5 92 82 95 18 85 27 92 77 68 46\n 57 61 4 58 94 50 31 25 34 80 94 82 24 98 74 98 93 80 25 99 19 34 12 55 71 21 5 61 37 22 15 50 27 12 59 97 38 83 84 54 79 51 93 95 66 12 80 20 28 86\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 655816003 3668 3351\nprocessing times :\n 66 46 25 30 17 40 17 20 73 5 60 3 91 34 81 58 48 71 57 5 8 19 78 2 1 78 8 14 46 98 50 88 28 66 43 23 93 52 1 77 54 45 56 54 57 23 18 88 38 72\n 55 63 71 21 74 65 52 91 12 22 12 26 97 30 30 12 94 46 20 73 58 10 77 27 33 53 23 2 65 35 7 54 43 87 56 4 29 35 37 53 10 90 95 85 2 36 85 5 3 45\n 65 35 49 2 95 14 67 8 62 25 2 40 68 75 72 5 5 10 33 56 89 54 31 1 61 25 11 7 88 65 74 16 87 57 89 85 46 54 23 23 96 79 70 33 50 18 65 87 18 15\n 57 72 48 6 10 98 55 71 19 28 31 79 69 11 4 12 71 62 2 95 35 82 57 7 24 62 70 89 87 21 54 16 72 31 24 94 18 83 36 73 67 74 75 93 16 74 70 16 81 93\n 58 66 5 69 38 93 59 56 26 96 60 18 74 93 12 56 36 71 38 96 84 84 65 17 78 45 83 53 60 60 9 7 51 85 66 6 3 93 88 40 85 92 15 51 55 19 58 84 4 23\n 38 23 13 1 10 76 49 2 81 43 51 71 29 44 26 27 27 56 21 76 88 9 33 6 40 64 5 5 7 5 76 63 35 94 65 25 6 87 60 33 67 81 93 98 9 94 49 27 62 90\n 5 13 36 54 76 40 67 31 35 48 85 41 82 95 15 24 77 6 79 36 18 21 34 42 74 46 1 88 29 95 67 41 98 31 25 70 62 45 59 68 22 81 44 80 88 25 93 61 1 97\n 26 40 84 84 74 39 65 15 71 92 44 27 93 2 55 44 55 23 25 1 51 12 47 98 41 18 44 72 88 60 29 99 2 17 79 6 29 89 4 70 10 79 64 92 42 79 56 94 26 93\n 66 41 74 62 70 30 66 11 51 43 32 23 20 1 54 55 65 22 99 97 21 63 45 70 41 6 70 33 97 32 28 54 63 16 12 2 50 48 34 75 45 2 39 4 46 11 66 59 28 74\n 93 95 48 71 30 22 3 22 82 35 56 14 88 41 4 52 17 95 15 85 12 11 24 71 46 59 16 33 53 22 49 44 76 88 45 52 31 66 17 68 99 78 87 45 78 51 87 4 45 9\n 39 12 45 34 11 71 53 28 93 61 61 78 13 49 15 31 93 83 20 1 13 36 6 22 44 65 87 50 96 51 48 89 69 83 22 26 29 67 70 59 34 18 4 65 58 35 86 34 49 88\n 42 79 25 18 75 45 54 19 80 15 22 56 63 56 79 82 92 19 45 32 11 59 22 14 88 82 82 71 8 13 53 71 98 99 54 20 62 18 81 60 1 93 8 92 60 87 11 24 11 98\n 40 62 8 13 87 40 27 44 41 70 10 94 25 10 36 87 37 86 76 70 17 92 90 58 19 97 80 28 67 59 9 92 7 19 82 60 60 58 74 70 72 33 71 68 94 82 46 78 37 69\n 7 34 69 18 98 8 58 86 77 50 50 82 16 17 68 65 92 37 47 70 66 30 7 37 5 52 86 36 29 4 99 53 52 9 8 50 62 14 21 88 7 85 62 10 61 92 47 77 37 96\n 50 4 20 19 58 22 56 92 59 34 17 39 59 7 59 2 70 72 90 56 26 50 4 8 60 60 80 38 51 25 97 73 46 82 92 42 65 12 34 23 99 48 41 40 76 89 42 90 61 25\n 27 60 79 50 15 65 80 67 70 94 61 55 2 55 78 27 13 20 38 75 23 61 37 43 69 2 44 25 12 31 1 54 94 63 91 27 55 74 77 77 81 29 91 20 99 27 30 85 5 4\n 64 44 58 7 69 12 5 69 46 23 95 24 58 88 46 65 31 84 4 73 43 97 49 2 54 12 31 52 29 98 46 83 78 52 63 66 45 49 21 13 9 87 3 15 55 5 8 94 60 18\n 20 65 50 76 75 7 82 49 3 56 38 85 29 26 23 28 19 10 72 33 21 79 55 69 38 15 58 36 11 98 2 74 16 21 10 98 74 84 55 19 20 37 90 76 10 81 27 52 21 1\n 79 18 99 75 47 96 6 22 3 29 12 53 42 61 49 56 9 6 54 57 16 95 26 25 71 50 38 15 85 20 25 67 7 12 50 8 82 5 9 41 85 77 74 17 38 42 20 68 93 15\n 28 91 32 56 70 51 9 94 63 33 89 6 41 22 68 83 79 69 44 64 77 46 76 64 25 55 30 89 96 71 69 88 24 41 53 8 58 19 50 21 43 18 74 50 20 81 98 92 21 83\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 1315102446 3752 3336\nprocessing times :\n 48 92 43 35 7 51 85 66 87 71 16 40 22 12 2 90 63 52 15 6 18 87 66 7 43 27 78 80 73 86 82 33 92 8 87 64 7 26 79 49 71 72 69 30 28 46 75 78 34 4\n 23 69 33 11 5 54 42 12 40 30 51 94 24 28 84 69 44 98 36 21 9 48 30 15 21 43 91 49 86 36 41 10 75 56 70 73 57 51 34 62 3 34 27 29 25 97 30 28 48 99\n 51 84 28 63 86 99 27 24 36 83 24 54 34 49 43 5 70 56 71 12 30 77 55 92 78 79 52 19 16 21 37 85 56 29 56 23 19 52 39 4 46 59 22 76 34 63 32 72 92 72\n 26 46 30 49 3 81 4 46 95 20 56 57 85 31 44 1 11 72 6 68 62 18 21 48 32 42 79 74 82 3 64 90 10 72 2 49 88 53 59 88 97 98 94 95 93 95 6 1 15 66\n 8 37 33 4 8 38 97 75 76 93 69 10 25 40 88 90 57 39 29 97 51 97 5 75 91 80 81 60 97 14 2 55 97 60 8 30 87 42 16 56 86 4 30 15 24 23 57 81 77 43\n 82 97 3 46 86 62 26 56 67 87 46 66 53 34 52 81 68 48 4 25 76 46 13 72 72 82 32 25 58 17 99 54 81 73 93 73 79 54 72 37 68 22 94 37 15 31 46 33 82 75\n 1 77 92 57 46 75 2 14 14 79 64 8 73 15 71 6 54 59 49 38 21 60 8 35 81 96 61 89 58 32 59 89 99 7 79 38 1 67 63 42 3 29 23 21 25 48 33 92 2 12\n 32 38 67 93 80 75 59 51 7 65 6 59 30 67 41 32 63 7 8 89 51 81 9 13 27 74 59 98 31 98 48 74 76 75 78 11 71 54 10 96 97 75 41 30 73 84 22 8 98 68\n 1 59 53 22 10 48 94 46 57 55 66 69 7 13 64 83 39 46 59 36 69 47 83 25 12 28 30 49 81 56 96 89 73 52 12 98 12 40 70 35 58 95 41 71 90 3 68 5 18 26\n 2 21 86 8 33 88 33 65 8 89 46 76 57 51 58 62 59 71 12 11 82 56 57 53 45 96 31 39 12 13 8 49 4 33 22 30 34 19 24 56 96 35 43 8 5 65 64 20 54 38\n 28 81 96 99 79 97 15 6 77 98 5 51 51 60 17 98 46 87 44 18 71 93 97 44 18 59 9 45 78 67 65 50 87 29 80 14 70 10 30 19 51 4 23 9 62 30 20 69 88 22\n 43 63 67 22 82 41 69 81 21 54 42 53 52 26 69 80 46 10 81 99 6 90 79 34 56 75 54 94 84 55 64 14 18 6 27 20 54 30 58 35 66 85 78 15 29 31 45 41 84 51\n 4 40 5 37 80 46 14 81 16 10 79 35 41 83 13 93 55 48 35 75 66 82 3 79 78 48 99 91 29 87 27 2 48 33 92 15 55 24 59 41 49 88 67 49 81 89 43 24 70 74\n 44 23 89 96 80 44 69 7 10 15 55 27 55 2 82 42 88 84 38 69 31 5 3 37 14 35 61 43 38 48 89 86 37 20 33 1 8 61 41 40 10 10 75 9 81 40 13 10 53 28\n 44 6 18 51 77 47 27 17 42 84 3 69 3 6 94 58 65 36 28 68 73 81 12 89 53 14 88 78 63 81 29 15 81 84 36 8 60 24 57 87 61 57 85 45 69 15 7 87 58 61\n 82 73 84 63 14 73 84 9 38 67 76 18 70 69 4 58 66 11 1 51 38 16 81 39 56 83 27 29 93 70 64 22 84 25 73 81 10 46 32 38 68 40 33 79 64 36 62 82 44 99\n 6 49 84 72 39 51 77 59 97 5 83 51 9 9 59 30 86 49 46 13 45 51 68 82 6 99 12 8 36 24 82 73 66 69 71 70 61 42 77 10 2 6 24 97 15 91 32 68 17 1\n 49 25 46 37 56 50 9 62 10 89 66 98 10 70 92 36 82 54 34 34 5 12 3 56 44 41 14 25 78 25 89 83 78 23 51 7 20 30 30 30 63 82 40 39 37 44 2 27 71 45\n 57 88 88 43 25 81 3 3 78 97 74 71 50 70 23 43 51 97 57 77 90 58 75 4 12 2 4 28 54 39 30 71 89 33 85 2 69 20 64 94 3 41 37 36 74 53 49 77 13 37\n 34 31 15 32 45 50 81 46 93 13 47 50 70 21 41 12 18 28 22 60 69 49 38 80 52 45 34 3 61 96 99 49 78 34 78 79 64 55 63 24 58 25 93 73 45 93 37 64 92 59\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 1949668355 3635 3313\nprocessing times :\n 82 3 55 23 36 62 51 80 13 86 56 69 42 86 6 58 61 5 9 27 6 37 41 11 47 99 28 53 75 81 11 22 42 36 7 71 96 85 20 17 71 23 80 52 89 84 80 3 30 36\n 70 41 97 12 22 53 81 56 88 86 38 26 46 59 51 82 59 90 15 16 83 82 77 88 63 52 67 14 86 68 3 62 4 57 11 96 72 71 82 10 3 54 22 71 7 66 5 14 15 82\n 18 12 86 18 84 67 81 92 61 69 31 76 12 3 97 18 87 96 5 11 98 37 7 15 68 97 85 10 97 85 17 63 30 77 72 22 73 87 68 2 99 2 20 47 10 14 50 53 27 78\n 48 9 30 28 54 8 30 95 65 82 21 76 84 69 21 51 70 7 93 7 34 85 48 8 12 34 73 85 24 64 26 94 30 45 33 4 37 86 57 19 87 81 32 53 98 44 1 31 36 61\n 49 73 71 34 98 80 5 30 32 70 49 35 11 52 87 58 71 85 12 56 82 11 5 99 32 17 75 23 44 29 98 1 82 64 38 24 3 61 60 12 33 42 15 10 68 68 34 2 81 45\n 50 37 12 56 21 15 16 45 24 24 35 50 86 88 82 37 7 48 68 65 19 91 11 20 25 23 64 7 80 13 72 29 58 55 90 44 59 56 5 24 74 63 75 25 42 41 11 35 79 42\n 85 35 70 6 84 40 26 52 85 36 97 39 39 42 12 22 9 63 68 84 54 9 1 13 25 5 51 15 94 19 33 15 95 10 55 22 10 60 79 75 87 95 45 79 20 44 52 86 88 62\n 96 31 50 14 5 86 23 22 77 52 2 86 64 92 86 45 5 28 79 97 89 63 46 40 20 2 61 61 71 45 62 36 96 69 25 89 3 12 37 61 30 48 41 70 18 43 95 25 12 13\n 95 95 6 43 77 81 38 76 85 88 27 86 82 22 6 88 40 83 27 58 1 44 3 74 6 13 41 10 66 64 32 50 45 40 82 75 97 18 45 39 44 55 71 49 35 13 45 26 13 97\n 15 95 85 57 30 49 64 94 80 2 37 95 26 93 38 3 72 69 59 26 28 97 62 71 26 95 73 21 56 36 74 62 6 67 89 18 30 81 75 24 17 87 35 61 43 83 29 90 58 32\n 11 89 88 3 7 93 88 23 92 26 50 68 29 92 44 56 38 59 43 33 49 62 24 83 35 98 8 82 16 79 2 38 50 97 26 2 20 69 42 52 83 51 23 61 74 31 91 77 54 29\n 24 71 51 44 43 76 19 89 46 96 42 14 88 21 33 60 69 99 93 62 3 12 2 55 55 50 13 89 18 78 5 70 32 67 21 4 62 35 60 42 68 18 39 82 28 54 8 6 1 54\n 94 80 61 79 5 71 4 45 29 34 59 81 24 79 8 59 80 76 3 33 86 49 8 29 26 17 34 31 18 48 4 78 90 48 21 74 30 96 79 97 37 1 46 68 67 27 74 58 65 29\n 27 3 92 58 58 12 45 74 5 59 23 13 89 48 98 20 82 28 21 37 72 74 19 21 32 5 32 55 92 49 6 66 85 26 61 82 52 32 85 98 64 20 78 21 63 33 96 74 22 60\n 12 73 37 55 12 37 69 89 17 54 22 39 70 29 93 51 41 89 26 31 61 99 50 73 46 57 33 22 37 46 81 86 14 11 18 21 3 45 71 5 37 79 1 36 65 22 77 48 58 71\n 95 62 37 47 1 36 1 98 16 75 17 89 19 69 38 6 11 85 68 21 90 90 21 92 57 8 59 49 37 48 26 97 14 82 42 92 66 80 41 69 32 64 64 52 25 53 33 49 80 82\n 6 53 68 81 33 54 64 12 24 87 30 97 3 41 40 63 52 48 97 71 40 43 78 6 18 27 60 26 41 50 27 11 78 51 56 25 30 2 56 24 95 33 12 65 72 70 10 69 21 7\n 67 77 19 83 43 85 57 89 41 21 31 52 6 99 45 79 48 44 20 88 70 65 59 73 84 50 56 45 31 82 85 32 28 73 41 51 36 68 23 78 98 34 77 64 55 39 26 83 28 65\n 88 15 30 64 25 5 81 38 8 99 15 12 72 97 27 22 48 56 89 88 66 89 75 47 14 47 97 58 25 11 81 53 74 9 25 28 16 66 81 95 22 99 62 58 80 18 27 14 41 42\n 9 99 81 80 95 51 9 56 96 7 2 31 27 8 18 80 69 86 35 2 44 6 72 23 78 96 99 95 50 14 35 4 77 64 5 98 49 98 64 79 65 5 37 26 90 27 69 55 84 90\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 1923497586 3698 3460\nprocessing times :\n 1 96 21 57 7 34 72 12 80 99 28 80 30 15 95 19 12 59 66 51 6 36 74 53 25 68 37 42 68 74 93 39 75 54 10 60 15 75 71 22 10 65 39 99 77 39 50 14 75 28\n 92 74 20 70 43 6 77 25 68 83 28 13 74 18 71 11 17 27 89 14 13 40 97 70 96 13 66 77 2 41 69 34 10 91 98 60 3 86 55 95 73 65 24 22 5 67 39 58 4 30\n 95 75 24 3 83 67 88 75 28 65 54 65 34 17 51 98 94 22 57 37 90 38 20 85 49 37 29 84 93 99 44 39 18 40 24 98 61 72 21 76 87 32 8 17 54 43 3 65 33 36\n 70 18 19 76 7 34 66 72 16 95 80 10 63 14 89 65 43 44 28 39 59 91 70 24 96 1 92 79 57 88 60 70 38 94 94 30 50 17 43 28 33 48 48 81 50 86 23 95 3 80\n 17 74 87 39 14 28 12 49 88 91 53 40 1 55 39 35 99 17 69 67 13 98 79 20 57 68 17 27 25 36 67 73 34 47 65 79 31 54 56 33 66 30 89 45 44 91 18 67 94 41\n 78 27 15 55 28 28 26 98 98 77 79 12 96 78 29 28 14 52 27 51 46 98 97 38 78 89 67 91 51 62 79 93 25 61 59 20 92 1 35 97 79 37 72 76 89 7 79 85 40 24\n 6 73 64 30 30 99 61 26 38 46 76 65 51 39 23 71 63 94 62 87 43 45 46 9 10 42 43 46 7 15 32 80 4 73 42 98 24 25 13 38 3 69 38 61 8 54 90 3 5 25\n 31 38 36 35 52 13 78 31 8 62 36 98 7 3 5 82 41 2 63 56 85 85 25 98 58 16 99 61 21 26 67 96 70 89 5 45 38 79 73 99 33 1 84 79 44 39 16 50 39 55\n 24 83 59 58 60 15 15 27 47 25 43 11 20 36 3 42 51 11 86 55 20 3 64 19 49 70 28 53 96 52 44 24 40 66 2 89 70 69 3 77 96 40 66 75 81 52 78 86 44 85\n 79 28 43 20 16 9 80 36 14 86 70 87 77 44 52 86 12 49 68 56 59 87 82 5 23 6 15 42 63 66 59 98 67 73 94 27 56 96 81 92 68 92 77 94 93 28 75 74 34 80\n 3 65 73 81 38 71 3 40 6 98 4 23 23 2 66 67 8 76 58 82 63 18 17 5 75 52 95 55 62 84 5 33 72 52 8 74 70 5 38 7 86 41 99 98 2 51 13 96 78 49\n 59 42 18 51 95 82 96 45 25 80 42 66 41 1 14 66 89 35 2 63 80 34 45 42 81 27 15 42 80 11 4 84 25 45 42 61 4 34 54 46 80 1 94 8 56 52 13 39 62 84\n 53 7 27 44 36 21 53 38 37 90 34 1 83 64 69 30 18 74 9 70 41 5 70 5 4 65 53 17 6 98 84 39 3 9 50 58 87 54 41 87 9 49 93 70 4 13 60 41 48 75\n 86 28 67 29 53 24 95 66 32 66 61 18 99 48 31 66 15 93 64 77 67 74 90 44 51 17 50 80 44 63 19 24 24 35 79 62 11 59 14 89 16 96 72 95 92 34 64 83 66 6\n 71 54 48 16 22 14 39 99 68 32 20 7 26 2 58 92 86 45 19 90 54 51 88 72 44 85 20 5 10 98 44 6 44 12 55 14 66 28 80 64 13 73 44 11 89 78 6 10 44 28\n 77 33 22 77 90 23 10 44 1 53 58 40 48 94 20 34 16 99 27 80 24 19 34 6 65 11 14 97 14 77 58 86 72 20 22 2 28 16 54 19 77 7 27 19 80 80 40 49 46 85\n 55 56 21 77 83 43 11 64 59 37 96 27 9 63 82 31 27 67 82 65 74 41 10 36 69 1 21 72 37 54 88 65 97 71 13 90 88 39 46 89 99 82 14 14 63 67 16 46 28 91\n 69 34 9 7 43 62 29 70 28 62 34 67 16 83 64 32 43 67 37 79 31 41 3 11 71 21 26 98 39 73 59 33 71 49 22 6 68 14 36 17 30 83 94 53 30 74 24 47 76 28\n 20 35 25 81 19 4 42 58 18 19 73 14 44 13 11 55 91 51 42 47 94 43 68 77 42 75 17 85 54 83 30 52 89 54 74 86 27 22 24 11 12 8 15 21 75 84 29 15 26 83\n 38 32 13 10 23 28 42 68 78 39 76 4 45 25 23 77 3 20 49 35 29 59 14 94 11 17 80 70 20 25 12 78 58 13 22 53 92 7 62 94 8 81 5 24 98 85 75 57 37 96\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 1805594913 3716 3427\nprocessing times :\n 25 14 99 5 68 98 72 39 79 13 24 14 82 90 28 50 75 86 57 4 73 82 22 75 6 32 92 84 54 37 73 16 26 50 36 97 94 57 91 39 16 55 47 33 30 50 87 85 71 2\n 77 67 89 40 6 5 85 62 19 73 55 24 18 64 41 55 37 44 45 5 26 34 9 65 23 89 86 22 97 59 24 45 70 66 33 86 86 23 7 80 24 96 24 74 62 43 6 83 75 77\n 2 27 92 7 64 44 84 76 43 18 27 91 23 17 84 90 98 93 96 56 99 78 23 70 96 3 69 68 75 85 45 36 80 56 39 35 8 28 78 29 39 87 75 97 22 61 88 22 7 19\n 2 8 28 1 17 76 43 79 88 13 3 2 39 39 16 95 40 13 27 73 7 62 35 40 68 95 34 12 60 6 66 74 26 77 20 45 81 34 30 54 12 38 87 63 69 22 81 91 90 47\n 86 85 80 21 79 59 67 27 29 5 13 8 84 42 15 18 13 18 75 23 5 60 96 32 98 26 67 94 17 90 49 39 97 3 13 52 50 32 16 59 79 8 16 4 7 45 4 94 64 79\n 68 82 27 7 47 59 96 94 65 19 82 44 33 13 88 93 78 4 57 44 44 42 15 68 95 81 73 26 76 52 27 55 7 85 53 63 98 62 16 71 45 66 60 82 63 54 22 13 74 90\n 47 44 33 15 31 53 44 8 22 88 30 1 24 81 83 96 10 86 15 98 3 27 92 23 13 82 53 93 31 79 32 27 2 64 57 62 30 79 11 66 86 10 34 97 47 38 29 11 89 51\n 2 51 72 39 67 57 19 11 18 75 24 96 61 68 1 35 21 9 27 63 52 27 12 70 27 26 11 28 72 96 76 37 9 2 79 50 52 47 37 93 64 68 5 57 37 47 3 51 27 96\n 91 66 32 65 75 89 82 11 82 33 64 82 53 67 21 24 44 59 39 84 6 83 10 72 96 13 64 42 11 20 18 77 30 35 91 11 27 15 12 15 73 20 56 24 63 35 81 15 48 51\n 64 49 4 45 21 56 19 75 3 96 97 17 53 38 25 7 25 24 82 53 32 57 83 61 59 4 56 75 16 18 70 88 53 61 37 57 16 72 53 76 75 69 35 35 20 79 22 52 4 97\n 35 21 89 51 47 64 57 71 48 50 78 43 40 33 59 81 46 35 28 57 14 92 29 40 54 10 22 39 33 92 85 38 44 60 66 57 62 59 10 34 23 82 94 48 85 88 20 32 57 82\n 76 89 41 75 35 45 68 3 71 94 76 88 1 29 59 21 34 55 85 54 98 2 53 89 56 79 61 54 72 22 97 89 96 73 40 52 63 29 7 66 11 47 11 68 77 29 8 22 13 18\n 87 61 91 63 65 95 70 60 34 4 39 44 87 50 71 50 82 80 75 30 74 43 48 10 81 53 56 97 76 18 21 33 69 19 50 99 63 37 85 5 59 18 61 68 82 70 24 35 90 94\n 78 45 82 71 80 67 35 72 92 96 31 24 41 35 79 63 74 58 61 50 44 68 98 87 39 61 96 87 93 87 95 22 89 4 18 77 25 51 2 49 20 41 4 50 50 67 95 41 51 31\n 30 86 47 86 3 38 82 91 83 59 98 17 54 37 33 34 29 5 88 89 28 23 21 95 62 9 92 98 98 60 14 42 4 78 29 47 13 50 16 4 80 12 31 69 57 77 61 92 84 92\n 63 18 23 55 25 47 91 8 14 7 37 74 56 88 9 14 64 40 22 10 17 16 1 52 11 10 17 49 60 81 79 71 22 44 27 3 34 20 30 5 42 63 20 43 1 81 83 99 58 69\n 69 45 63 62 63 19 44 2 14 8 61 79 72 90 2 7 82 9 12 94 68 99 27 85 37 3 5 9 67 17 81 33 85 89 19 93 54 41 16 76 21 11 78 45 85 82 32 48 76 33\n 62 71 98 10 28 46 8 9 43 74 93 62 99 82 67 45 22 21 97 73 88 51 89 37 58 7 41 2 69 44 19 57 56 75 61 34 89 95 71 57 91 61 24 25 10 8 81 38 99 11\n 30 63 24 57 8 4 17 97 38 66 35 86 7 85 10 3 59 74 52 78 40 84 39 4 44 62 1 67 12 7 61 95 15 96 67 23 2 74 70 13 90 17 11 22 64 27 13 76 79 81\n 37 2 36 60 82 50 46 87 27 24 69 91 10 80 74 14 51 40 95 51 54 66 62 25 15 27 89 90 2 4 89 11 34 64 11 36 73 70 85 82 60 19 30 5 20 45 77 31 70 46\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 1861070898 3709 3383\nprocessing times :\n 43 50 51 88 95 52 15 25 2 21 74 1 89 78 14 48 91 33 46 1 39 51 62 77 77 29 82 39 62 27 47 17 60 15 94 97 65 35 5 1 66 49 3 33 98 45 3 25 74 61\n 57 90 81 15 66 1 89 31 20 46 93 78 41 30 42 71 6 16 76 63 54 38 88 36 69 51 67 54 76 47 37 15 6 62 19 7 97 37 37 60 81 28 87 95 85 76 69 44 70 24\n 31 19 14 10 78 15 91 35 79 78 45 79 47 33 75 81 66 78 41 38 55 75 5 57 67 12 21 88 47 42 12 25 32 89 11 34 10 95 9 88 79 60 59 81 4 58 40 95 81 1\n 67 68 38 40 28 5 26 59 77 60 69 57 43 90 30 46 49 77 67 54 7 38 26 83 95 44 84 41 5 12 87 16 4 83 97 58 80 22 1 89 98 92 90 20 14 76 23 54 18 34\n 67 37 74 4 15 93 4 9 33 97 79 75 91 79 23 60 97 55 76 14 2 3 3 64 94 63 48 67 32 15 45 31 10 70 75 71 50 25 74 94 7 79 25 74 14 95 54 74 44 44\n 25 21 12 6 56 19 75 35 64 89 99 36 32 53 67 68 97 9 16 55 91 5 81 67 86 26 41 48 28 19 88 37 40 23 27 11 8 5 87 39 32 23 82 32 95 19 88 29 54 11\n 26 49 42 15 66 67 40 97 13 54 23 1 74 95 45 3 80 78 31 76 52 79 71 58 9 61 20 53 62 45 25 59 71 96 34 50 25 36 18 34 39 39 81 62 25 82 91 26 63 78\n 91 13 94 52 7 71 1 84 38 61 32 49 63 72 86 63 80 87 55 53 99 7 35 72 45 14 36 35 86 81 41 58 34 43 47 10 23 36 56 84 53 85 32 8 33 67 65 35 19 92\n 20 64 97 82 36 99 41 30 80 70 61 42 51 15 16 60 47 15 26 96 82 98 59 19 1 50 16 2 6 68 86 62 58 23 12 89 19 31 70 68 29 47 43 47 45 92 81 44 84 64\n 30 58 95 96 92 54 18 20 27 59 22 93 6 95 58 12 16 93 40 87 5 41 88 92 64 45 13 61 51 70 81 25 54 97 85 7 65 84 80 65 21 9 32 95 20 28 64 29 82 82\n 22 39 64 56 9 17 55 40 87 60 92 11 51 78 3 73 48 38 92 81 85 90 46 72 58 60 94 85 94 63 23 92 45 97 14 80 59 30 24 44 99 33 90 25 54 91 61 29 1 59\n 64 60 75 83 41 27 94 22 96 21 53 77 85 33 20 1 90 71 62 94 86 61 15 87 53 30 77 9 34 2 39 54 8 44 12 93 18 88 21 54 94 5 43 89 98 99 43 85 80 7\n 77 26 69 97 76 37 50 99 80 68 24 47 7 70 91 87 73 7 20 70 3 7 12 76 2 66 45 13 33 66 8 54 4 50 98 38 52 58 57 13 8 9 8 95 27 28 17 38 72 89\n 53 51 99 24 98 52 67 31 34 61 60 17 82 25 12 61 84 89 11 25 50 11 61 81 14 72 86 87 7 57 81 33 52 4 73 98 2 27 46 84 7 48 67 86 6 36 14 86 75 21\n 94 51 39 5 19 71 76 23 92 81 88 8 71 9 68 16 87 3 7 38 69 23 17 27 60 75 65 33 47 60 23 30 73 4 82 8 36 20 70 42 62 49 21 3 18 96 41 94 41 58\n 27 38 8 21 26 5 2 65 58 83 10 34 29 82 89 32 47 43 42 42 16 7 11 27 46 78 73 27 69 38 41 38 50 28 76 39 51 57 39 46 69 15 22 7 67 16 50 76 13 11\n 11 54 39 65 70 17 17 99 97 45 35 50 5 48 75 71 44 60 59 24 39 64 39 1 65 65 1 12 97 31 21 71 1 37 89 24 15 94 22 94 33 84 45 19 48 89 33 63 38 26\n 3 64 6 65 89 13 71 22 2 33 99 71 51 61 33 57 56 33 32 52 86 6 9 88 87 57 98 92 39 38 78 54 31 53 92 69 52 87 11 34 67 52 30 9 78 34 14 24 64 6\n 23 2 29 60 1 88 17 54 8 9 10 20 12 7 5 68 16 79 54 55 41 26 6 78 35 74 68 72 6 73 12 18 85 3 66 72 72 61 22 77 86 46 72 31 27 8 67 5 88 31\n 55 36 65 96 96 96 91 82 3 47 4 93 74 12 95 82 42 99 57 44 79 48 23 31 57 55 52 4 83 88 67 67 20 34 41 59 74 35 8 26 90 25 23 23 71 1 72 49 73 18\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 715643788 3765 3457\nprocessing times :\n 89 97 1 77 90 52 35 52 5 67 44 6 98 14 2 86 53 14 68 6 20 37 74 58 80 40 78 23 54 12 43 33 56 39 17 93 16 45 63 22 87 72 65 46 79 61 30 76 64 47\n 32 95 41 54 68 63 90 23 94 78 82 53 57 51 45 3 31 59 97 55 99 94 15 72 51 49 59 82 21 38 53 28 84 61 29 29 24 43 47 89 15 55 75 55 34 26 60 66 88 21\n 38 7 50 55 69 26 98 99 81 63 17 23 92 28 78 94 4 98 61 74 20 21 79 29 56 24 9 12 42 77 38 3 50 36 4 96 51 35 27 97 2 65 32 14 44 4 45 69 62 57\n 28 17 44 83 94 78 34 54 4 81 73 27 14 43 29 35 25 40 39 3 60 16 69 17 93 49 24 13 28 51 91 44 55 3 32 99 23 96 63 91 94 6 25 56 49 98 97 6 77 88\n 52 7 77 29 8 53 30 16 7 4 73 55 5 26 14 30 92 16 64 20 3 46 58 18 99 67 40 62 11 23 24 27 86 32 26 97 12 61 78 77 75 35 5 32 47 89 95 62 68 39\n 46 84 28 42 22 43 68 7 45 18 40 89 77 57 37 72 36 58 17 84 80 33 83 76 28 76 41 85 21 70 3 41 65 86 66 74 75 1 12 99 59 91 40 5 38 14 41 78 99 38\n 31 27 38 81 59 71 83 80 78 20 6 68 72 24 95 63 84 54 6 33 39 69 58 51 44 59 7 27 74 3 51 44 68 84 20 47 7 85 92 35 2 94 23 33 7 3 23 63 94 68\n 15 86 51 83 45 67 68 14 23 40 52 68 87 56 68 44 99 21 82 91 18 71 28 85 70 85 19 1 24 43 39 74 47 47 92 87 42 9 37 70 61 27 18 20 33 39 1 83 32 1\n 37 71 68 90 51 73 84 86 58 98 84 84 21 49 12 16 52 81 86 91 35 60 9 7 80 17 30 84 76 38 48 57 79 43 82 55 46 82 77 56 49 88 13 99 84 18 74 49 54 31\n 18 48 88 43 14 90 33 62 86 83 14 8 73 33 54 75 67 58 60 43 62 4 49 80 35 47 68 55 21 44 72 81 64 78 70 60 61 50 37 13 6 36 38 20 23 59 3 63 81 1\n 51 92 5 6 60 68 30 51 1 8 2 55 78 35 51 19 94 85 40 50 61 52 79 94 48 99 47 30 18 81 17 4 22 21 35 44 2 48 85 60 37 7 62 14 83 26 13 50 72 58\n 74 42 88 65 1 79 25 42 8 27 39 43 53 30 11 87 25 78 63 27 61 35 15 73 67 94 51 76 52 93 31 22 73 62 27 16 81 55 29 92 45 75 63 81 18 68 60 2 48 30\n 4 73 56 2 60 55 13 34 79 62 19 15 25 6 43 26 15 92 82 65 94 30 20 37 26 81 31 96 42 40 41 85 59 67 11 41 47 22 91 17 75 72 76 45 67 57 87 23 88 78\n 78 52 4 39 71 19 45 69 3 63 48 49 28 74 7 54 69 31 1 33 82 30 39 81 66 68 87 48 73 70 11 80 90 99 20 48 17 59 15 40 37 93 98 53 35 91 7 34 55 43\n 32 68 56 55 71 41 16 40 73 54 65 8 90 74 35 1 66 99 99 1 17 93 60 43 50 37 28 43 3 83 72 86 19 49 67 54 75 36 6 68 37 9 35 24 26 97 89 92 94 86\n 47 83 7 72 50 20 98 98 90 66 77 89 23 64 57 42 83 90 63 26 22 94 26 22 54 74 62 57 3 53 20 60 87 66 18 83 65 42 49 3 65 78 54 12 74 88 15 71 35 41\n 94 24 98 6 7 4 99 99 9 32 37 60 31 64 19 84 71 1 95 55 45 39 95 88 45 16 5 87 72 35 86 50 62 2 82 17 68 24 24 80 44 55 57 4 31 65 59 21 95 16\n 22 52 8 93 19 71 93 42 28 91 51 14 62 22 23 83 63 84 34 66 49 61 51 91 42 39 80 96 9 31 29 97 50 8 26 72 92 21 3 36 50 80 57 15 6 89 29 89 75 98\n 83 69 26 53 50 20 22 39 85 63 58 83 92 48 3 20 58 10 5 16 74 35 21 68 26 77 94 29 17 35 72 27 84 93 16 71 18 99 3 90 89 65 16 15 53 69 55 22 61 26\n 74 18 66 40 70 95 28 84 51 25 40 53 88 20 38 99 40 1 73 6 65 99 62 53 26 64 36 77 29 10 2 66 25 91 9 46 75 73 61 19 73 2 35 12 27 15 41 83 15 35\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 20 464843328 3777 3438\nprocessing times :\n 4 20 62 71 69 87 96 25 98 41 99 1 94 91 36 71 28 50 11 14 76 20 78 70 43 59 88 68 48 48 39 36 2 51 91 4 32 62 46 55 73 97 71 50 54 73 44 95 53 18\n 44 54 7 54 61 18 45 64 81 57 13 45 60 12 89 20 47 81 11 56 30 51 18 91 48 94 32 67 95 75 82 41 7 39 25 49 39 53 66 96 36 41 8 92 92 82 78 19 12 54\n 15 80 61 37 72 73 55 19 80 48 10 17 67 21 9 79 89 20 94 47 90 44 49 28 46 82 96 91 28 93 30 64 41 53 86 6 68 25 8 62 17 49 92 20 77 24 53 71 88 88\n 24 75 31 34 87 88 62 59 39 4 74 90 29 99 74 4 86 22 10 96 56 28 90 71 12 1 6 41 30 21 64 92 1 85 94 24 83 4 57 8 17 83 47 57 93 54 79 5 30 90\n 58 55 34 66 67 70 16 25 34 1 18 2 86 34 82 55 59 21 31 53 25 69 71 85 80 39 71 66 74 57 54 2 27 55 7 94 85 3 46 7 26 95 21 4 98 9 52 48 59 17\n 53 26 89 34 29 32 28 46 49 55 8 34 40 48 68 59 87 1 87 91 99 95 21 62 87 84 96 47 60 82 60 53 98 48 30 39 52 22 63 19 49 50 20 85 31 99 61 96 82 75\n 80 35 39 85 45 13 81 78 25 81 21 87 40 30 11 76 79 75 77 17 51 29 11 73 50 86 56 93 79 57 85 17 88 89 39 41 8 21 33 36 75 2 65 57 22 41 89 62 43 30\n 56 8 1 51 73 4 58 24 69 39 33 16 75 19 1 30 44 8 45 19 53 38 39 68 83 94 34 1 23 32 70 35 78 89 88 92 50 64 61 35 81 69 80 38 44 49 85 26 15 97\n 11 64 32 10 37 86 35 41 7 56 10 15 25 15 54 3 43 10 27 10 39 2 24 50 64 44 34 97 93 81 15 42 34 87 53 82 64 96 60 20 78 12 15 63 81 98 97 2 2 44\n 64 94 23 88 52 23 26 9 63 24 8 32 97 17 76 45 28 89 75 71 46 40 66 87 91 50 54 60 10 79 43 34 77 92 3 98 40 19 68 85 2 51 35 91 68 3 26 49 37 25\n 50 83 82 78 44 23 66 24 56 92 30 31 88 85 50 34 91 55 7 49 38 73 47 95 48 54 94 21 41 30 42 44 28 82 4 64 38 9 37 87 37 26 80 83 50 50 50 42 88 55\n 22 1 88 69 50 79 59 18 98 21 35 94 57 71 76 97 7 87 89 53 19 69 66 61 18 86 51 90 80 22 6 52 16 84 12 74 69 22 12 80 45 51 96 80 87 92 20 95 16 64\n 50 62 28 4 11 13 46 23 41 74 15 67 39 4 13 43 84 41 33 41 82 99 63 29 86 28 80 7 1 5 64 17 81 48 9 77 92 15 49 41 17 32 25 89 9 29 38 2 91 57\n 24 2 51 49 39 62 85 70 86 18 90 36 51 20 23 17 23 47 66 3 59 30 85 16 81 95 81 14 96 23 44 8 15 48 95 62 90 41 70 56 50 29 39 72 94 70 40 33 16 79\n 56 43 63 60 3 89 52 42 24 53 77 12 71 14 62 75 97 3 54 41 71 11 12 54 21 14 82 35 21 38 52 82 40 47 91 60 61 21 67 29 46 74 11 72 56 81 80 87 44 41\n 59 41 64 30 51 16 64 72 68 31 93 86 91 34 6 27 62 35 57 67 96 69 8 92 1 37 69 57 59 85 86 98 96 55 9 2 71 85 2 96 7 78 55 7 50 5 60 61 68 87\n 72 81 8 73 93 38 85 94 88 69 90 26 23 44 97 67 53 75 69 44 13 47 98 41 46 25 56 50 35 59 78 44 57 21 59 60 52 62 14 58 24 8 22 72 37 90 96 26 23 91\n 41 80 74 15 89 24 36 86 98 51 32 92 51 98 88 1 13 50 80 56 50 58 75 4 73 90 2 73 75 67 99 93 9 27 61 64 43 32 56 61 55 99 77 66 25 28 87 25 18 61\n 18 39 96 18 16 48 22 53 71 24 17 47 44 62 4 85 74 59 41 13 82 26 39 28 59 49 87 32 65 24 48 72 15 5 68 36 7 52 45 87 42 68 9 53 59 65 81 12 39 62\n 90 34 66 10 95 51 15 4 66 24 53 87 26 64 13 16 23 61 78 58 13 99 87 70 84 3 48 78 79 20 51 83 51 1 2 73 82 34 26 49 39 24 39 69 1 1 79 27 20 22\n" }, { "path": "examples/user_fssp_gls/TestingData/Taillard/t_j50_m5.txt", "content": "number of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 1328042058 2724 2712\nprocessing times :\n 75 87 13 11 41 43 93 69 80 13 24 72 38 81 83 88 26 6 89 67 70 30 89 30 68 21 78 46 99 10 17 23 83 47 86 18 67 46 4 14 4 20 88 50 84 58 93 76 50 30\n 26 37 25 95 49 12 59 17 46 20 52 44 92 75 95 33 10 45 2 62 62 82 29 29 94 20 42 80 94 35 8 41 65 4 71 30 14 32 50 30 27 98 39 84 65 12 58 45 49 15\n 48 4 92 92 72 45 5 98 93 17 79 11 16 89 81 92 45 61 39 28 94 87 23 1 55 91 67 91 4 60 38 25 90 93 13 65 25 34 47 98 91 11 46 50 77 5 14 47 80 45\n 26 67 4 14 93 54 21 20 6 18 75 25 16 77 28 24 15 77 36 16 32 46 21 81 28 70 89 54 96 62 46 60 19 97 13 7 44 7 73 15 66 70 97 33 97 64 73 28 4 87\n 77 94 9 57 29 79 55 73 65 86 25 39 76 24 38 5 91 29 22 27 39 31 46 18 93 58 85 58 97 10 79 93 2 87 17 18 10 50 8 26 14 21 15 10 85 46 42 18 36 2\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 200382020 2834 2808\nprocessing times :\n 27 69 78 90 23 6 23 28 98 57 96 85 60 34 42 73 31 11 60 57 88 38 43 30 77 85 58 58 45 72 86 83 3 14 91 27 17 13 21 82 91 11 88 99 8 6 71 53 2 2\n 91 9 33 97 27 17 97 96 1 30 5 78 58 20 42 97 96 75 89 66 9 59 84 93 83 58 92 82 12 89 81 20 4 93 12 75 35 58 70 9 79 29 45 27 71 89 21 78 4 17\n 97 49 17 54 52 74 44 8 75 19 91 94 77 80 20 48 90 30 5 20 46 72 10 97 44 85 40 68 62 76 60 65 91 63 67 26 57 22 67 70 30 57 67 29 63 77 28 73 63 20\n 67 72 50 12 54 69 35 26 80 13 17 10 74 63 17 11 15 30 91 89 93 62 16 49 73 58 68 15 92 31 16 56 42 32 85 2 39 39 79 86 35 30 10 42 77 69 47 83 8 27\n 11 73 28 12 71 20 65 56 44 79 26 43 44 28 70 64 57 53 84 45 6 77 39 94 72 93 80 35 32 59 31 86 52 7 99 20 95 21 63 73 97 49 77 83 73 94 35 89 9 29\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 496319842 2621 2596\nprocessing times :\n 38 23 13 1 10 76 49 2 81 43 51 71 29 44 26 27 27 56 21 76 88 9 33 6 40 64 5 5 7 5 76 63 35 94 65 25 6 87 60 33 67 81 93 98 9 94 49 27 62 90\n 5 13 36 54 76 40 67 31 35 48 85 41 82 95 15 24 77 6 79 36 18 21 34 42 74 46 1 88 29 95 67 41 98 31 25 70 62 45 59 68 22 81 44 80 88 25 93 61 1 97\n 26 40 84 84 74 39 65 15 71 92 44 27 93 2 55 44 55 23 25 1 51 12 47 98 41 18 44 72 88 60 29 99 2 17 79 6 29 89 4 70 10 79 64 92 42 79 56 94 26 93\n 66 41 74 62 70 30 66 11 51 43 32 23 20 1 54 55 65 22 99 97 21 63 45 70 41 6 70 33 97 32 28 54 63 16 12 2 50 48 34 75 45 2 39 4 46 11 66 59 28 74\n 93 95 48 71 30 22 3 22 82 35 56 14 88 41 4 52 17 95 15 85 12 11 24 71 46 59 16 33 53 22 49 44 76 88 45 52 31 66 17 68 99 78 87 45 78 51 87 4 45 9\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 1203030903 2751 2740\nprocessing times :\n 37 5 8 37 71 65 13 35 52 63 58 13 69 35 9 90 57 90 55 36 84 31 50 44 38 12 57 70 92 1 72 94 96 78 30 46 60 95 82 94 62 7 51 44 31 40 29 78 57 42\n 77 64 66 33 47 67 61 99 54 66 57 65 24 30 95 40 85 46 46 55 39 22 41 41 40 19 56 16 48 38 25 2 99 67 94 50 26 54 67 57 18 8 81 49 96 18 50 46 22 48\n 91 36 63 69 83 29 33 97 1 74 74 53 74 54 21 41 92 2 83 63 87 37 64 65 40 77 1 12 54 39 24 79 47 80 40 44 58 20 50 16 99 22 33 60 87 55 70 93 52 41\n 91 7 40 92 47 49 87 76 49 41 29 27 14 68 9 69 94 51 64 67 47 66 27 49 92 74 59 36 79 16 43 4 3 11 13 95 64 38 32 76 66 37 28 7 2 88 92 58 24 2\n 5 73 99 23 83 9 89 94 84 97 99 43 71 86 51 22 2 60 17 81 6 40 32 82 63 50 74 36 56 10 24 82 90 29 99 38 7 77 50 4 11 73 16 27 98 30 51 77 54 92\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 1730708564 2863 2837\nprocessing times :\n 17 43 13 20 41 94 18 28 8 71 82 42 90 76 62 95 74 80 33 91 35 80 79 68 97 98 3 22 52 80 32 75 78 36 46 16 36 93 39 19 95 91 49 35 93 11 93 6 96 19\n 33 98 67 81 43 72 32 66 97 36 36 67 1 47 87 12 91 21 6 6 1 38 69 77 3 75 64 53 18 10 97 18 48 70 60 75 94 14 53 90 19 42 86 15 58 7 65 40 51 61\n 98 90 4 39 79 76 53 77 10 2 97 31 62 28 74 60 53 74 88 11 88 92 7 80 67 27 21 43 59 30 17 4 7 21 83 44 70 30 39 35 8 6 92 39 55 34 98 47 99 16\n 90 93 35 65 66 10 48 81 27 49 61 73 60 88 42 62 28 55 58 55 90 61 73 3 74 94 30 81 9 87 58 42 59 48 29 83 60 83 76 43 90 14 84 10 15 38 90 80 19 15\n 75 68 39 71 31 43 5 32 6 56 56 72 23 95 50 53 27 8 18 81 57 54 99 20 10 19 18 53 73 10 74 93 22 75 84 9 27 32 51 83 70 13 1 81 13 98 58 28 3 21\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 450926852 2829 2793\nprocessing times :\n 12 72 29 16 22 61 69 71 86 16 54 53 64 96 79 68 98 87 40 74 22 23 47 55 21 90 68 14 42 41 40 63 23 75 4 31 87 25 47 70 1 49 59 11 93 38 5 43 82 33\n 26 89 86 10 16 72 96 47 9 56 8 69 87 84 62 52 82 66 67 33 3 53 95 42 59 77 38 12 1 66 24 17 58 71 88 63 60 86 8 8 44 99 80 76 94 75 63 57 76 34\n 27 97 53 16 36 28 50 41 42 86 2 45 86 43 92 73 99 84 83 61 7 8 62 3 21 50 71 95 70 60 4 58 16 30 80 71 59 75 52 25 86 48 53 54 98 36 9 78 80 88\n 52 30 62 8 45 77 90 52 39 95 86 15 98 59 22 43 85 93 6 46 51 97 79 46 71 18 33 13 3 32 28 48 8 42 26 26 95 44 74 82 28 4 42 81 56 38 50 12 43 51\n 24 57 68 58 76 70 72 56 56 55 89 23 42 26 87 17 38 24 82 55 47 7 99 89 20 65 3 45 89 96 16 42 70 69 77 46 20 71 91 8 34 72 40 82 60 59 59 43 72 10\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 1303135678 2725 2689\nprocessing times :\n 82 73 84 63 14 73 84 9 38 67 76 18 70 69 4 58 66 11 1 51 38 16 81 39 56 83 27 29 93 70 64 22 84 25 73 81 10 46 32 38 68 40 33 79 64 36 62 82 44 99\n 6 49 84 72 39 51 77 59 97 5 83 51 9 9 59 30 86 49 46 13 45 51 68 82 6 99 12 8 36 24 82 73 66 69 71 70 61 42 77 10 2 6 24 97 15 91 32 68 17 1\n 49 25 46 37 56 50 9 62 10 89 66 98 10 70 92 36 82 54 34 34 5 12 3 56 44 41 14 25 78 25 89 83 78 23 51 7 20 30 30 30 63 82 40 39 37 44 2 27 71 45\n 57 88 88 43 25 81 3 3 78 97 74 71 50 70 23 43 51 97 57 77 90 58 75 4 12 2 4 28 54 39 30 71 89 33 85 2 69 20 64 94 3 41 37 36 74 53 49 77 13 37\n 34 31 15 32 45 50 81 46 93 13 47 50 70 21 41 12 18 28 22 60 69 49 38 80 52 45 34 3 61 96 99 49 78 34 78 79 64 55 63 24 58 25 93 73 45 93 37 64 92 59\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 1273398721 2683 2667\nprocessing times :\n 9 19 86 38 71 82 12 20 37 22 97 85 93 33 69 70 29 48 28 76 91 54 71 36 13 44 27 23 95 15 25 88 46 5 38 74 21 36 21 4 96 78 7 72 80 38 17 98 88 78\n 80 54 73 83 15 5 27 20 75 24 73 88 17 24 53 86 10 30 71 5 11 97 10 84 58 47 69 80 49 74 37 94 51 1 9 16 89 2 80 38 94 93 89 95 95 63 17 98 2 19\n 28 58 52 11 21 97 49 55 16 4 82 60 5 52 42 61 87 89 76 46 32 18 3 60 34 69 47 95 92 70 71 73 58 17 26 39 60 72 93 27 27 63 59 76 97 85 57 49 60 30\n 70 1 23 18 42 96 2 52 49 82 4 67 77 24 68 37 28 65 93 68 18 6 49 67 93 3 10 80 44 26 83 4 50 74 14 8 67 18 60 3 43 31 59 69 13 46 53 27 28 63\n 55 39 86 40 92 2 65 91 67 92 55 40 1 81 2 78 25 27 46 61 46 59 16 41 65 75 69 68 68 23 30 29 37 64 44 69 36 9 45 8 50 10 46 83 91 79 39 83 36 28\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 587288402 2552 2527\nprocessing times :\n 34 40 22 6 50 64 48 74 67 22 26 13 24 54 22 9 28 48 83 85 79 78 40 15 95 75 73 41 52 71 84 73 25 41 74 15 58 55 47 12 36 48 96 47 64 5 24 78 59 4\n 24 85 19 94 59 65 42 8 10 15 96 63 30 20 31 94 35 84 83 53 57 25 71 22 31 35 40 76 14 48 42 11 92 68 55 88 52 36 62 42 51 68 10 38 29 56 23 71 45 98\n 20 61 69 28 69 35 17 59 16 54 6 18 2 4 80 45 2 18 83 21 41 51 85 56 88 40 20 16 22 98 56 69 90 9 81 65 38 75 60 81 59 94 3 19 15 29 94 48 39 3\n 65 39 68 40 82 31 29 17 69 44 19 29 60 27 93 35 17 1 99 96 1 62 84 42 60 42 66 1 1 31 41 62 83 74 38 56 57 54 45 39 85 40 21 84 17 24 65 98 90 46\n 47 62 11 6 21 60 82 2 31 27 81 34 7 6 53 19 28 63 29 34 96 39 19 45 64 72 26 59 51 74 3 11 96 50 23 43 36 52 9 44 32 2 78 83 69 47 17 35 45 30\nnumber of jobs, number of machines, initial seed, upper bound and lower bound :\n 50 5 248421594 2782 2776\nprocessing times :\n 24 1 57 86 35 9 55 8 93 11 39 10 84 80 59 37 80 69 13 19 25 92 45 14 73 85 75 96 33 17 76 96 4 16 9 66 46 64 3 93 74 29 68 38 86 90 50 11 64 4\n 51 57 82 47 82 14 79 57 88 79 22 72 58 78 18 48 72 38 71 82 61 73 50 56 95 16 6 7 86 21 27 44 64 32 46 37 39 96 44 70 41 56 44 27 41 66 87 42 7 54\n 8 54 15 47 73 33 73 35 45 75 83 12 59 95 96 75 62 44 43 30 47 36 65 85 1 71 13 54 2 82 16 15 14 49 68 28 87 85 90 17 54 59 25 23 60 60 68 70 80 4\n 59 85 73 87 87 89 48 57 59 73 66 95 61 13 79 88 19 18 21 33 11 8 8 83 13 89 63 64 53 28 17 2 77 61 73 69 23 56 78 65 85 99 52 78 8 58 51 43 52 41\n 67 99 57 47 93 35 32 77 28 75 95 15 18 97 37 53 97 73 60 39 48 9 17 83 10 2 66 50 36 45 86 8 47 52 98 22 55 62 23 82 32 20 38 23 40 55 79 66 97 29\n" }, { "path": "examples/user_fssp_gls/TrainingData/1.txt", "content": "50 20\n0 76 1 91 2 87 3 60 4 40 5 90 6 60 7 42 8 45 9 24 10 38 11 4 12 87 13 20 14 59 15 67 16 90 17 1 18 82 19 95 \n0 50 1 22 2 47 3 100 4 93 5 45 6 81 7 11 8 31 9 81 10 14 11 93 12 94 13 24 14 7 15 72 16 20 17 88 18 56 19 93 \n0 75 1 2 2 26 3 10 4 32 5 26 6 77 7 8 8 11 9 37 10 44 11 70 12 97 13 4 14 53 15 49 16 21 17 67 18 78 19 68 \n0 26 1 34 2 93 3 9 4 51 5 77 6 53 7 74 8 11 9 25 10 27 11 75 12 69 13 70 14 17 15 38 16 1 17 28 18 21 19 33 \n0 95 1 71 2 84 3 63 4 88 5 9 6 90 7 30 8 73 9 3 10 59 11 97 12 78 13 6 14 19 15 30 16 39 17 68 18 10 19 52 \n0 39 1 43 2 55 3 40 4 31 5 88 6 100 7 97 8 39 9 95 10 40 11 27 12 54 13 65 14 64 15 27 16 49 17 57 18 37 19 100 \n0 41 1 28 2 94 3 36 4 13 5 62 6 9 7 23 8 95 9 62 10 56 11 78 12 54 13 33 14 49 15 34 16 61 17 94 18 72 19 91 \n0 21 1 68 2 55 3 70 4 77 5 18 6 90 7 57 8 9 9 7 10 56 11 19 12 64 13 14 14 32 15 10 16 65 17 8 18 71 19 93 \n0 87 1 22 2 34 3 11 4 7 5 8 6 60 7 58 8 91 9 69 10 92 11 98 12 49 13 39 14 37 15 37 16 60 17 18 18 38 19 63 \n0 27 1 7 2 88 3 66 4 72 5 63 6 74 7 77 8 56 9 59 10 15 11 39 12 89 13 17 14 45 15 27 16 90 17 78 18 36 19 8 \n0 42 1 53 2 10 3 6 4 61 5 40 6 57 7 64 8 25 9 92 10 90 11 17 12 15 13 41 14 9 15 26 16 32 17 45 18 74 19 78 \n0 76 1 94 2 43 3 2 4 83 5 56 6 79 7 100 8 44 9 83 10 77 11 30 12 56 13 42 14 77 15 72 16 70 17 85 18 36 19 32 \n0 81 1 53 2 37 3 60 4 44 5 65 6 64 7 75 8 35 9 5 10 14 11 75 12 97 13 51 14 52 15 59 16 95 17 20 18 40 19 20 \n0 58 1 13 2 68 3 51 4 42 5 46 6 75 7 16 8 22 9 5 10 6 11 83 12 31 13 71 14 68 15 6 16 72 17 76 18 6 19 98 \n0 72 1 3 2 54 3 17 4 47 5 74 6 6 7 74 8 55 9 68 10 35 11 65 12 79 13 33 14 53 15 2 16 67 17 79 18 45 19 62 \n0 45 1 4 2 86 3 81 4 25 5 16 6 55 7 52 8 51 9 24 10 47 11 96 12 4 13 77 14 18 15 83 16 95 17 31 18 39 19 92 \n0 50 1 70 2 95 3 46 4 74 5 89 6 89 7 83 8 42 9 6 10 30 11 53 12 68 13 92 14 51 15 54 16 3 17 71 18 56 19 13 \n0 28 1 72 2 3 3 37 4 58 5 86 6 49 7 52 8 7 9 89 10 65 11 96 12 74 13 6 14 22 15 28 16 40 17 95 18 67 19 35 \n0 87 1 78 2 24 3 16 4 57 5 75 6 26 7 12 8 42 9 24 10 34 11 81 12 34 13 13 14 39 15 52 16 25 17 1 18 33 19 40 \n0 10 1 2 2 100 3 90 4 99 5 9 6 52 7 77 8 77 9 43 10 20 11 15 12 75 13 65 14 87 15 53 16 37 17 23 18 84 19 99 \n0 56 1 67 2 13 3 33 4 99 5 2 6 81 7 22 8 88 9 49 10 35 11 3 12 81 13 87 14 64 15 28 16 10 17 60 18 44 19 37 \n0 25 1 72 2 24 3 33 4 98 5 68 6 95 7 69 8 31 9 44 10 50 11 47 12 63 13 59 14 17 15 14 16 78 17 63 18 90 19 45 \n0 64 1 75 2 81 3 65 4 4 5 85 6 14 7 60 8 89 9 22 10 33 11 24 12 67 13 42 14 38 15 12 16 42 17 3 18 40 19 46 \n0 21 1 49 2 66 3 13 4 13 5 97 6 96 7 75 8 52 9 37 10 86 11 22 12 78 13 43 14 14 15 96 16 7 17 96 18 24 19 19 \n0 32 1 49 2 2 3 58 4 91 5 14 6 80 7 33 8 34 9 38 10 72 11 28 12 52 13 97 14 26 15 26 16 56 17 46 18 91 19 14 \n0 1 1 95 2 63 3 84 4 93 5 72 6 99 7 34 8 65 9 39 10 99 11 54 12 18 13 88 14 64 15 78 16 12 17 80 18 65 19 84 \n0 29 1 22 2 65 3 97 4 93 5 64 6 100 7 84 8 87 9 91 10 34 11 29 12 29 13 82 14 7 15 14 16 65 17 8 18 20 19 8 \n0 76 1 78 2 2 3 90 4 3 5 67 6 55 7 48 8 33 9 92 10 13 11 98 12 7 13 39 14 53 15 73 16 81 17 37 18 31 19 51 \n0 70 1 79 2 6 3 14 4 3 5 22 6 15 7 47 8 21 9 71 10 73 11 74 12 35 13 13 14 81 15 11 16 36 17 73 18 31 19 6 \n0 33 1 36 2 70 3 32 4 84 5 47 6 84 7 15 8 22 9 100 10 100 11 48 12 60 13 92 14 39 15 22 16 72 17 20 18 7 19 72 \n0 47 1 50 2 36 3 54 4 72 5 91 6 28 7 52 8 15 9 42 10 79 11 43 12 30 13 73 14 29 15 16 16 82 17 47 18 16 19 65 \n0 25 1 11 2 23 3 33 4 79 5 57 6 91 7 4 8 16 9 89 10 75 11 95 12 93 13 63 14 17 15 27 16 1 17 47 18 40 19 11 \n0 1 1 82 2 67 3 62 4 53 5 25 6 67 7 64 8 87 9 92 10 8 11 38 12 26 13 75 14 69 15 56 16 69 17 79 18 82 19 3 \n0 15 1 58 2 34 3 5 4 69 5 58 6 6 7 63 8 1 9 33 10 81 11 69 12 26 13 85 14 58 15 54 16 50 17 99 18 26 19 3 \n0 96 1 23 2 50 3 96 4 54 5 11 6 23 7 69 8 83 9 58 10 29 11 11 12 69 13 61 14 69 15 67 16 22 17 63 18 69 19 58 \n0 95 1 98 2 9 3 21 4 87 5 79 6 17 7 8 8 4 9 63 10 18 11 46 12 19 13 27 14 35 15 15 16 6 17 57 18 92 19 24 \n0 38 1 78 2 88 3 79 4 58 5 79 6 86 7 19 8 40 9 96 10 24 11 14 12 86 13 68 14 19 15 34 16 95 17 35 18 26 19 88 \n0 83 1 24 2 89 3 94 4 20 5 48 6 99 7 29 8 15 9 43 10 23 11 29 12 56 13 54 14 40 15 86 16 43 17 85 18 75 19 97 \n0 48 1 21 2 76 3 56 4 67 5 3 6 73 7 49 8 96 9 24 10 13 11 48 12 54 13 16 14 88 15 75 16 96 17 14 18 44 19 16 \n0 14 1 7 2 8 3 95 4 46 5 49 6 87 7 27 8 98 9 42 10 64 11 39 12 34 13 19 14 93 15 50 16 82 17 5 18 45 19 59 \n0 88 1 5 2 84 3 34 4 90 5 46 6 1 7 33 8 99 9 21 10 100 11 63 12 64 13 27 14 82 15 1 16 60 17 7 18 71 19 1 \n0 12 1 5 2 87 3 2 4 35 5 65 6 96 7 92 8 56 9 4 10 17 11 55 12 41 13 16 14 73 15 57 16 11 17 50 18 1 19 71 \n0 68 1 42 2 61 3 24 4 64 5 70 6 7 7 75 8 36 9 3 10 36 11 73 12 30 13 81 14 9 15 8 16 33 17 24 18 98 19 54 \n0 56 1 27 2 48 3 20 4 69 5 73 6 49 7 13 8 49 9 79 10 41 11 40 12 93 13 44 14 89 15 32 16 91 17 59 18 98 19 29 \n0 97 1 72 2 13 3 78 4 50 5 39 6 67 7 17 8 54 9 92 10 91 11 99 12 61 13 97 14 10 15 24 16 86 17 63 18 45 19 29 \n0 83 1 41 2 86 3 42 4 13 5 3 6 87 7 16 8 84 9 97 10 15 11 54 12 72 13 32 14 54 15 35 16 79 17 15 18 84 19 96 \n0 24 1 33 2 14 3 29 4 6 5 39 6 94 7 2 8 57 9 69 10 59 11 91 12 22 13 34 14 28 15 34 16 92 17 3 18 22 19 93 \n0 92 1 1 2 61 3 5 4 50 5 23 6 34 7 57 8 23 9 61 10 14 11 91 12 52 13 38 14 27 15 43 16 24 17 34 18 75 19 79 \n0 37 1 56 2 37 3 86 4 73 5 64 6 35 7 28 8 31 9 25 10 95 11 28 12 68 13 20 14 85 15 74 16 60 17 100 18 27 19 45 \n0 69 1 72 2 66 3 86 4 50 5 2 6 94 7 56 8 75 9 48 10 20 11 12 12 49 13 26 14 16 15 96 16 60 17 72 18 68 19 77 \n" }, { "path": "examples/user_fssp_gls/TrainingData/10.txt", "content": "50 13\n0 47 1 15 2 72 3 95 4 88 5 41 6 25 7 24 8 61 9 49 10 79 11 46 12 71 \n0 2 1 52 2 20 3 25 4 79 5 89 6 55 7 68 8 74 9 94 10 50 11 11 12 56 \n0 6 1 33 2 66 3 81 4 31 5 92 6 89 7 99 8 92 9 40 10 52 11 88 12 4 \n0 24 1 41 2 80 3 75 4 95 5 80 6 54 7 97 8 7 9 53 10 74 11 42 12 38 \n0 24 1 14 2 32 3 5 4 62 5 6 6 95 7 11 8 79 9 76 10 11 11 86 12 72 \n0 6 1 97 2 58 3 84 4 89 5 61 6 66 7 63 8 57 9 20 10 29 11 45 12 40 \n0 54 1 75 2 32 3 98 4 95 5 88 6 69 7 93 8 39 9 8 10 37 11 10 12 55 \n0 92 1 34 2 84 3 71 4 97 5 5 6 10 7 71 8 11 9 37 10 62 11 5 12 71 \n0 62 1 35 2 21 3 84 4 13 5 1 6 70 7 19 8 39 9 90 10 79 11 2 12 47 \n0 52 1 34 2 87 3 79 4 25 5 44 6 45 7 59 8 8 9 20 10 23 11 36 12 47 \n0 23 1 33 2 12 3 22 4 37 5 92 6 57 7 82 8 65 9 39 10 26 11 94 12 44 \n0 74 1 19 2 70 3 86 4 71 5 84 6 93 7 73 8 12 9 89 10 35 11 31 12 32 \n0 48 1 84 2 99 3 62 4 85 5 32 6 33 7 8 8 82 9 47 10 66 11 46 12 42 \n0 58 1 53 2 44 3 68 4 4 5 36 6 51 7 7 8 91 9 36 10 97 11 7 12 73 \n0 72 1 38 2 55 3 33 4 85 5 19 6 24 7 70 8 24 9 47 10 72 11 19 12 18 \n0 39 1 75 2 83 3 50 4 79 5 54 6 49 7 29 8 11 9 50 10 49 11 85 12 11 \n0 46 1 93 2 15 3 46 4 82 5 94 6 87 7 22 8 42 9 82 10 94 11 30 12 62 \n0 92 1 24 2 98 3 75 4 12 5 87 6 70 7 62 8 59 9 11 10 23 11 53 12 56 \n0 75 1 67 2 84 3 71 4 95 5 20 6 55 7 73 8 22 9 92 10 1 11 58 12 48 \n0 74 1 77 2 65 3 27 4 63 5 84 6 63 7 49 8 31 9 52 10 85 11 12 12 31 \n0 78 1 74 2 26 3 23 4 68 5 42 6 66 7 15 8 21 9 3 10 92 11 8 12 9 \n0 70 1 43 2 52 3 2 4 94 5 35 6 22 7 16 8 33 9 90 10 100 11 17 12 19 \n0 64 1 33 2 27 3 62 4 37 5 40 6 99 7 20 8 82 9 38 10 4 11 8 12 96 \n0 61 1 77 2 56 3 41 4 41 5 95 6 84 7 37 8 95 9 13 10 75 11 27 12 34 \n0 62 1 78 2 67 3 25 4 1 5 69 6 88 7 4 8 85 9 58 10 54 11 77 12 21 \n0 44 1 58 2 32 3 37 4 19 5 92 6 89 7 53 8 46 9 69 10 93 11 100 12 94 \n0 86 1 65 2 99 3 86 4 8 5 46 6 14 7 46 8 63 9 28 10 79 11 7 12 52 \n0 19 1 50 2 58 3 36 4 53 5 37 6 88 7 75 8 57 9 98 10 92 11 44 12 61 \n0 4 1 29 2 75 3 25 4 33 5 1 6 77 7 25 8 10 9 2 10 91 11 84 12 79 \n0 26 1 37 2 56 3 63 4 66 5 52 6 28 7 16 8 81 9 15 10 83 11 7 12 51 \n0 41 1 2 2 20 3 99 4 87 5 67 6 87 7 2 8 21 9 42 10 32 11 57 12 36 \n0 52 1 14 2 70 3 50 4 36 5 93 6 12 7 28 8 45 9 76 10 24 11 68 12 92 \n0 41 1 8 2 61 3 85 4 79 5 30 6 51 7 44 8 86 9 39 10 9 11 51 12 12 \n0 91 1 82 2 43 3 12 4 31 5 93 6 35 7 82 8 64 9 64 10 2 11 65 12 51 \n0 60 1 78 2 32 3 92 4 18 5 29 6 79 7 34 8 32 9 79 10 9 11 49 12 87 \n0 70 1 73 2 52 3 2 4 40 5 9 6 34 7 20 8 70 9 55 10 65 11 46 12 7 \n0 3 1 90 2 95 3 91 4 4 5 98 6 53 7 37 8 90 9 65 10 14 11 30 12 10 \n0 43 1 91 2 42 3 25 4 80 5 10 6 17 7 12 8 20 9 80 10 85 11 85 12 66 \n0 48 1 70 2 24 3 81 4 21 5 2 6 40 7 53 8 90 9 5 10 87 11 91 12 49 \n0 83 1 99 2 99 3 15 4 75 5 99 6 27 7 53 8 75 9 89 10 99 11 75 12 66 \n0 27 1 44 2 3 3 30 4 92 5 44 6 6 7 37 8 24 9 26 10 45 11 33 12 63 \n0 53 1 78 2 65 3 98 4 38 5 57 6 81 7 54 8 93 9 28 10 51 11 19 12 86 \n0 46 1 40 2 95 3 32 4 5 5 76 6 22 7 65 8 35 9 78 10 69 11 4 12 47 \n0 50 1 24 2 18 3 100 4 22 5 97 6 22 7 44 8 23 9 29 10 46 11 77 12 72 \n0 89 1 11 2 49 3 38 4 62 5 64 6 72 7 98 8 21 9 30 10 61 11 30 12 65 \n0 95 1 18 2 92 3 31 4 23 5 68 6 26 7 3 8 13 9 64 10 50 11 71 12 8 \n0 37 1 73 2 5 3 56 4 92 5 79 6 88 7 17 8 64 9 15 10 16 11 17 12 53 \n0 73 1 93 2 69 3 34 4 33 5 79 6 81 7 12 8 99 9 52 10 20 11 36 12 52 \n0 31 1 31 2 63 3 43 4 92 5 41 6 27 7 36 8 72 9 45 10 29 11 6 12 9 \n0 43 1 96 2 72 3 36 4 90 5 87 6 57 7 71 8 71 9 78 10 25 11 46 12 77 \n" }, { "path": "examples/user_fssp_gls/TrainingData/11.txt", "content": "50 8\n0 77 1 56 2 22 3 11 4 95 5 27 6 58 7 90 \n0 38 1 5 2 25 3 76 4 40 5 39 6 52 7 77 \n0 61 1 88 2 83 3 35 4 63 5 87 6 87 7 24 \n0 56 1 60 2 46 3 61 4 10 5 52 6 49 7 45 \n0 15 1 60 2 51 3 73 4 53 5 100 6 62 7 7 \n0 72 1 87 2 82 3 64 4 23 5 9 6 15 7 54 \n0 57 1 49 2 28 3 55 4 97 5 85 6 52 7 89 \n0 47 1 30 2 86 3 75 4 1 5 1 6 80 7 29 \n0 42 1 49 2 18 3 42 4 92 5 25 6 64 7 89 \n0 11 1 12 2 87 3 51 4 88 5 50 6 10 7 74 \n0 8 1 18 2 98 3 71 4 93 5 36 6 78 7 2 \n0 54 1 93 2 70 3 56 4 66 5 74 6 83 7 97 \n0 82 1 33 2 47 3 53 4 66 5 74 6 38 7 98 \n0 90 1 68 2 64 3 37 4 57 5 32 6 51 7 58 \n0 48 1 67 2 41 3 94 4 16 5 75 6 46 7 8 \n0 71 1 20 2 20 3 36 4 40 5 50 6 23 7 50 \n0 65 1 32 2 60 3 20 4 99 5 1 6 42 7 72 \n0 74 1 34 2 47 3 17 4 8 5 36 6 58 7 55 \n0 29 1 6 2 78 3 10 4 12 5 26 6 4 7 87 \n0 62 1 17 2 67 3 76 4 35 5 75 6 99 7 12 \n0 94 1 92 2 45 3 96 4 65 5 12 6 2 7 88 \n0 59 1 31 2 58 3 96 4 91 5 19 6 96 7 31 \n0 81 1 98 2 12 3 38 4 41 5 16 6 56 7 80 \n0 4 1 94 2 46 3 94 4 25 5 59 6 82 7 93 \n0 84 1 40 2 36 3 82 4 57 5 64 6 5 7 14 \n0 73 1 99 2 30 3 26 4 51 5 21 6 88 7 67 \n0 20 1 60 2 27 3 89 4 25 5 31 6 64 7 87 \n0 59 1 53 2 49 3 73 4 82 5 37 6 56 7 93 \n0 66 1 35 2 73 3 7 4 69 5 28 6 30 7 15 \n0 35 1 31 2 34 3 85 4 33 5 13 6 74 7 91 \n0 67 1 73 2 38 3 98 4 70 5 10 6 31 7 17 \n0 27 1 20 2 43 3 44 4 17 5 65 6 96 7 27 \n0 97 1 3 2 1 3 75 4 3 5 12 6 41 7 85 \n0 81 1 59 2 40 3 27 4 85 5 53 6 35 7 77 \n0 31 1 89 2 29 3 25 4 56 5 35 6 67 7 62 \n0 73 1 84 2 50 3 49 4 37 5 98 6 3 7 73 \n0 8 1 4 2 36 3 97 4 33 5 91 6 2 7 99 \n0 37 1 47 2 40 3 27 4 45 5 48 6 64 7 37 \n0 39 1 36 2 59 3 15 4 45 5 91 6 23 7 8 \n0 15 1 87 2 34 3 37 4 54 5 91 6 73 7 3 \n0 99 1 70 2 23 3 35 4 35 5 43 6 99 7 18 \n0 50 1 7 2 27 3 36 4 42 5 42 6 76 7 12 \n0 9 1 97 2 26 3 68 4 38 5 45 6 63 7 80 \n0 64 1 54 2 71 3 68 4 11 5 80 6 96 7 52 \n0 16 1 65 2 39 3 94 4 56 5 75 6 15 7 100 \n0 10 1 85 2 47 3 9 4 47 5 79 6 52 7 89 \n0 87 1 15 2 13 3 50 4 67 5 18 6 13 7 14 \n0 80 1 27 2 11 3 5 4 16 5 71 6 79 7 1 \n0 54 1 48 2 60 3 85 4 43 5 20 6 53 7 41 \n0 80 1 58 2 57 3 89 4 65 5 6 6 55 7 43 \n" }, { "path": "examples/user_fssp_gls/TrainingData/12.txt", "content": "50 8\n0 9 1 8 2 91 3 32 4 27 5 8 6 27 7 69 \n0 17 1 100 2 47 3 15 4 35 5 30 6 24 7 84 \n0 29 1 60 2 99 3 20 4 9 5 28 6 70 7 73 \n0 76 1 79 2 70 3 28 4 50 5 57 6 79 7 3 \n0 60 1 33 2 46 3 45 4 55 5 86 6 43 7 79 \n0 73 1 29 2 28 3 71 4 43 5 23 6 44 7 3 \n0 90 1 44 2 20 3 56 4 6 5 86 6 99 7 15 \n0 49 1 27 2 38 3 69 4 41 5 24 6 3 7 10 \n0 19 1 8 2 50 3 35 4 50 5 36 6 34 7 36 \n0 88 1 16 2 67 3 51 4 4 5 43 6 31 7 5 \n0 4 1 74 2 71 3 61 4 78 5 32 6 47 7 65 \n0 41 1 20 2 14 3 5 4 8 5 57 6 55 7 99 \n0 11 1 12 2 75 3 7 4 1 5 14 6 15 7 75 \n0 46 1 67 2 70 3 6 4 64 5 36 6 88 7 17 \n0 32 1 59 2 10 3 65 4 32 5 13 6 61 7 7 \n0 76 1 52 2 100 3 45 4 48 5 54 6 95 7 7 \n0 91 1 23 2 47 3 97 4 90 5 49 6 90 7 40 \n0 19 1 92 2 85 3 50 4 61 5 87 6 100 7 39 \n0 68 1 71 2 90 3 82 4 68 5 56 6 96 7 29 \n0 48 1 76 2 62 3 25 4 92 5 42 6 29 7 23 \n0 86 1 58 2 15 3 33 4 90 5 22 6 90 7 15 \n0 64 1 18 2 55 3 1 4 82 5 29 6 14 7 7 \n0 9 1 94 2 30 3 95 4 81 5 3 6 14 7 20 \n0 85 1 78 2 72 3 87 4 11 5 80 6 35 7 73 \n0 62 1 43 2 83 3 35 4 34 5 75 6 62 7 99 \n0 14 1 65 2 55 3 61 4 19 5 10 6 71 7 36 \n0 56 1 39 2 57 3 40 4 97 5 5 6 40 7 15 \n0 80 1 97 2 12 3 52 4 81 5 52 6 18 7 69 \n0 55 1 65 2 2 3 92 4 80 5 5 6 11 7 91 \n0 99 1 100 2 44 3 16 4 54 5 35 6 86 7 71 \n0 88 1 40 2 14 3 7 4 67 5 50 6 11 7 73 \n0 18 1 22 2 10 3 12 4 57 5 59 6 64 7 30 \n0 64 1 5 2 88 3 98 4 65 5 47 6 72 7 9 \n0 61 1 58 2 32 3 5 4 88 5 72 6 69 7 78 \n0 27 1 31 2 39 3 49 4 27 5 71 6 46 7 20 \n0 31 1 56 2 36 3 52 4 14 5 68 6 97 7 81 \n0 11 1 58 2 79 3 78 4 91 5 68 6 62 7 54 \n0 66 1 19 2 60 3 14 4 88 5 88 6 77 7 62 \n0 30 1 15 2 36 3 85 4 96 5 76 6 58 7 82 \n0 34 1 70 2 37 3 49 4 30 5 37 6 93 7 54 \n0 8 1 19 2 38 3 95 4 79 5 70 6 65 7 50 \n0 5 1 30 2 4 3 59 4 62 5 18 6 12 7 88 \n0 4 1 88 2 72 3 11 4 3 5 99 6 56 7 42 \n0 86 1 31 2 34 3 66 4 13 5 40 6 76 7 78 \n0 19 1 89 2 41 3 44 4 50 5 60 6 67 7 20 \n0 72 1 3 2 50 3 83 4 46 5 5 6 74 7 93 \n0 33 1 58 2 44 3 29 4 81 5 37 6 48 7 33 \n0 19 1 80 2 63 3 60 4 90 5 92 6 35 7 44 \n0 11 1 22 2 48 3 64 4 12 5 16 6 55 7 76 \n0 99 1 64 2 23 3 62 4 10 5 48 6 77 7 35 \n" }, { "path": "examples/user_fssp_gls/TrainingData/13.txt", "content": "50 8\n0 41 1 56 2 69 3 23 4 17 5 87 6 47 7 79 \n0 71 1 68 2 19 3 100 4 22 5 90 6 20 7 15 \n0 57 1 9 2 53 3 42 4 53 5 73 6 59 7 19 \n0 47 1 70 2 16 3 8 4 20 5 98 6 18 7 77 \n0 43 1 91 2 91 3 35 4 97 5 66 6 74 7 79 \n0 98 1 57 2 38 3 81 4 3 5 80 6 42 7 40 \n0 25 1 80 2 67 3 88 4 24 5 43 6 57 7 75 \n0 86 1 31 2 70 3 76 4 26 5 63 6 88 7 36 \n0 43 1 16 2 69 3 35 4 90 5 90 6 71 7 16 \n0 4 1 5 2 97 3 35 4 75 5 33 6 13 7 80 \n0 62 1 20 2 19 3 41 4 49 5 93 6 24 7 38 \n0 24 1 62 2 86 3 11 4 96 5 36 6 12 7 6 \n0 37 1 31 2 15 3 82 4 88 5 85 6 42 7 8 \n0 12 1 30 2 70 3 91 4 80 5 21 6 98 7 89 \n0 84 1 10 2 77 3 30 4 46 5 46 6 54 7 75 \n0 95 1 31 2 80 3 69 4 8 5 44 6 54 7 95 \n0 83 1 99 2 25 3 18 4 25 5 95 6 99 7 95 \n0 42 1 18 2 17 3 44 4 23 5 9 6 77 7 48 \n0 86 1 34 2 14 3 97 4 52 5 15 6 67 7 39 \n0 78 1 71 2 39 3 31 4 47 5 65 6 61 7 15 \n0 54 1 16 2 70 3 90 4 28 5 8 6 1 7 24 \n0 47 1 42 2 92 3 55 4 12 5 23 6 1 7 93 \n0 5 1 82 2 37 3 92 4 89 5 24 6 68 7 81 \n0 88 1 19 2 14 3 62 4 45 5 43 6 84 7 34 \n0 81 1 74 2 53 3 77 4 41 5 26 6 43 7 12 \n0 94 1 36 2 95 3 7 4 75 5 27 6 62 7 79 \n0 68 1 27 2 7 3 51 4 87 5 19 6 3 7 73 \n0 54 1 37 2 50 3 57 4 82 5 23 6 37 7 22 \n0 93 1 20 2 89 3 75 4 92 5 25 6 36 7 18 \n0 47 1 37 2 12 3 73 4 82 5 25 6 56 7 9 \n0 82 1 12 2 55 3 16 4 70 5 77 6 11 7 38 \n0 25 1 99 2 10 3 18 4 95 5 1 6 44 7 81 \n0 70 1 52 2 61 3 74 4 68 5 31 6 42 7 61 \n0 60 1 16 2 7 3 61 4 99 5 83 6 57 7 87 \n0 2 1 91 2 14 3 58 4 15 5 67 6 98 7 71 \n0 92 1 41 2 49 3 76 4 53 5 2 6 77 7 37 \n0 12 1 14 2 52 3 40 4 16 5 75 6 16 7 17 \n0 75 1 47 2 79 3 75 4 24 5 29 6 59 7 69 \n0 40 1 78 2 63 3 81 4 74 5 72 6 5 7 36 \n0 83 1 61 2 88 3 56 4 54 5 12 6 97 7 35 \n0 59 1 71 2 75 3 85 4 35 5 83 6 68 7 97 \n0 86 1 80 2 80 3 93 4 24 5 24 6 91 7 82 \n0 48 1 67 2 56 3 86 4 34 5 78 6 81 7 57 \n0 31 1 13 2 100 3 32 4 85 5 84 6 92 7 29 \n0 13 1 69 2 2 3 38 4 37 5 81 6 95 7 46 \n0 21 1 53 2 41 3 72 4 18 5 93 6 39 7 72 \n0 53 1 32 2 53 3 8 4 91 5 65 6 90 7 90 \n0 25 1 43 2 85 3 9 4 5 5 89 6 84 7 24 \n0 54 1 19 2 64 3 69 4 64 5 2 6 84 7 70 \n0 98 1 74 2 20 3 70 4 62 5 1 6 13 7 85 \n" }, { "path": "examples/user_fssp_gls/TrainingData/14.txt", "content": "50 20\n0 67 1 17 2 62 3 50 4 96 5 18 6 71 7 20 8 99 9 74 10 98 11 22 12 68 13 16 14 37 15 59 16 12 17 7 18 13 19 43 \n0 51 1 4 2 64 3 29 4 9 5 20 6 2 7 63 8 56 9 7 10 78 11 60 12 5 13 62 14 75 15 97 16 67 17 6 18 43 19 64 \n0 53 1 77 2 10 3 40 4 48 5 72 6 81 7 35 8 52 9 55 10 23 11 57 12 94 13 89 14 1 15 41 16 86 17 74 18 92 19 71 \n0 9 1 42 2 71 3 84 4 81 5 66 6 60 7 97 8 31 9 61 10 75 11 3 12 81 13 99 14 69 15 40 16 53 17 96 18 46 19 34 \n0 8 1 99 2 60 3 44 4 1 5 100 6 45 7 27 8 14 9 38 10 93 11 2 12 86 13 79 14 16 15 39 16 81 17 19 18 65 19 31 \n0 97 1 99 2 94 3 97 4 4 5 95 6 19 7 67 8 84 9 25 10 5 11 86 12 9 13 96 14 20 15 23 16 25 17 65 18 48 19 28 \n0 43 1 43 2 55 3 42 4 31 5 99 6 91 7 66 8 70 9 14 10 11 11 19 12 97 13 87 14 68 15 22 16 26 17 44 18 6 19 14 \n0 51 1 35 2 31 3 46 4 32 5 15 6 22 7 22 8 75 9 66 10 19 11 15 12 59 13 4 14 78 15 49 16 25 17 67 18 79 19 85 \n0 27 1 93 2 60 3 9 4 18 5 61 6 49 7 80 8 9 9 52 10 41 11 12 12 18 13 11 14 68 15 47 16 32 17 33 18 18 19 11 \n0 87 1 39 2 70 3 41 4 98 5 18 6 100 7 67 8 83 9 10 10 91 11 49 12 4 13 15 14 9 15 60 16 17 17 67 18 27 19 89 \n0 3 1 92 2 9 3 80 4 42 5 39 6 57 7 80 8 71 9 51 10 58 11 59 12 36 13 2 14 20 15 22 16 87 17 20 18 29 19 36 \n0 30 1 2 2 20 3 6 4 60 5 16 6 88 7 22 8 73 9 76 10 45 11 6 12 73 13 94 14 84 15 84 16 66 17 60 18 88 19 78 \n0 16 1 93 2 46 3 60 4 15 5 89 6 3 7 43 8 65 9 11 10 58 11 18 12 47 13 70 14 62 15 39 16 32 17 97 18 36 19 2 \n0 43 1 44 2 59 3 49 4 76 5 48 6 65 7 90 8 74 9 28 10 83 11 63 12 21 13 90 14 71 15 45 16 50 17 28 18 26 19 59 \n0 73 1 75 2 67 3 41 4 9 5 42 6 9 7 70 8 62 9 85 10 21 11 77 12 37 13 58 14 15 15 50 16 8 17 23 18 73 19 54 \n0 84 1 17 2 41 3 68 4 99 5 1 6 81 7 16 8 38 9 19 10 39 11 23 12 48 13 10 14 89 15 35 16 14 17 34 18 25 19 6 \n0 27 1 55 2 41 3 52 4 69 5 62 6 79 7 83 8 25 9 21 10 97 11 96 12 100 13 70 14 97 15 12 16 60 17 28 18 90 19 98 \n0 7 1 35 2 15 3 80 4 14 5 38 6 76 7 5 8 98 9 91 10 97 11 74 12 53 13 17 14 25 15 31 16 47 17 76 18 84 19 82 \n0 35 1 22 2 62 3 84 4 72 5 77 6 58 7 90 8 19 9 58 10 25 11 32 12 15 13 27 14 35 15 39 16 22 17 97 18 88 19 100 \n0 56 1 47 2 91 3 33 4 76 5 45 6 6 7 67 8 10 9 34 10 90 11 86 12 61 13 1 14 98 15 55 16 11 17 40 18 32 19 72 \n0 44 1 29 2 26 3 15 4 56 5 72 6 98 7 52 8 43 9 82 10 87 11 67 12 15 13 5 14 71 15 49 16 40 17 9 18 5 19 12 \n0 5 1 28 2 49 3 85 4 18 5 46 6 42 7 53 8 1 9 59 10 11 11 64 12 59 13 95 14 59 15 15 16 3 17 40 18 46 19 14 \n0 3 1 86 2 60 3 6 4 88 5 18 6 96 7 55 8 3 9 12 10 74 11 54 12 41 13 97 14 45 15 10 16 37 17 47 18 49 19 17 \n0 68 1 17 2 74 3 39 4 99 5 55 6 100 7 83 8 50 9 57 10 57 11 64 12 97 13 39 14 18 15 84 16 10 17 21 18 71 19 70 \n0 97 1 78 2 69 3 40 4 85 5 91 6 56 7 18 8 16 9 44 10 9 11 36 12 70 13 37 14 95 15 72 16 73 17 27 18 54 19 90 \n0 84 1 35 2 38 3 85 4 69 5 91 6 28 7 21 8 86 9 83 10 6 11 12 12 42 13 26 14 10 15 80 16 100 17 14 18 97 19 60 \n0 49 1 16 2 68 3 7 4 57 5 95 6 52 7 85 8 9 9 43 10 69 11 90 12 52 13 81 14 69 15 72 16 45 17 85 18 94 19 35 \n0 37 1 39 2 14 3 90 4 13 5 75 6 53 7 93 8 52 9 54 10 100 11 24 12 22 13 95 14 14 15 65 16 40 17 4 18 36 19 29 \n0 34 1 93 2 66 3 27 4 25 5 21 6 54 7 94 8 24 9 75 10 88 11 88 12 92 13 25 14 69 15 91 16 83 17 23 18 66 19 54 \n0 32 1 74 2 31 3 74 4 1 5 59 6 38 7 32 8 27 9 38 10 21 11 6 12 59 13 100 14 62 15 54 16 5 17 11 18 10 19 22 \n0 34 1 2 2 9 3 97 4 21 5 46 6 89 7 54 8 55 9 73 10 2 11 6 12 23 13 33 14 64 15 65 16 30 17 100 18 66 19 55 \n0 64 1 17 2 70 3 13 4 61 5 30 6 40 7 58 8 70 9 30 10 62 11 65 12 27 13 35 14 43 15 6 16 27 17 89 18 56 19 93 \n0 55 1 36 2 99 3 65 4 67 5 2 6 46 7 92 8 18 9 74 10 69 11 51 12 81 13 81 14 39 15 42 16 46 17 38 18 33 19 56 \n0 32 1 9 2 36 3 44 4 50 5 78 6 95 7 64 8 1 9 27 10 16 11 52 12 51 13 93 14 100 15 9 16 36 17 65 18 95 19 91 \n0 94 1 14 2 18 3 53 4 13 5 24 6 40 7 73 8 7 9 55 10 50 11 96 12 47 13 36 14 80 15 10 16 50 17 57 18 74 19 100 \n0 41 1 65 2 82 3 71 4 14 5 53 6 24 7 92 8 100 9 27 10 87 11 66 12 82 13 70 14 60 15 67 16 61 17 78 18 22 19 61 \n0 19 1 64 2 14 3 67 4 30 5 94 6 11 7 12 8 51 9 56 10 17 11 13 12 77 13 74 14 95 15 3 16 81 17 25 18 74 19 3 \n0 48 1 60 2 31 3 37 4 81 5 47 6 48 7 53 8 90 9 44 10 26 11 13 12 19 13 79 14 66 15 88 16 25 17 20 18 46 19 89 \n0 59 1 44 2 82 3 46 4 73 5 13 6 6 7 36 8 80 9 27 10 64 11 51 12 30 13 21 14 95 15 81 16 70 17 99 18 1 19 60 \n0 45 1 69 2 47 3 96 4 16 5 1 6 19 7 33 8 7 9 67 10 95 11 66 12 67 13 83 14 57 15 46 16 32 17 86 18 96 19 1 \n0 89 1 10 2 9 3 42 4 69 5 36 6 79 7 63 8 17 9 13 10 90 11 91 12 78 13 53 14 74 15 56 16 84 17 16 18 54 19 99 \n0 72 1 96 2 35 3 24 4 52 5 67 6 24 7 20 8 96 9 19 10 84 11 97 12 44 13 75 14 55 15 80 16 7 17 38 18 74 19 70 \n0 98 1 71 2 26 3 39 4 74 5 32 6 50 7 78 8 33 9 69 10 54 11 36 12 9 13 57 14 32 15 17 16 100 17 49 18 24 19 2 \n0 3 1 73 2 89 3 22 4 1 5 2 6 85 7 94 8 42 9 100 10 59 11 40 12 17 13 30 14 60 15 65 16 38 17 80 18 12 19 91 \n0 100 1 22 2 32 3 28 4 60 5 70 6 39 7 32 8 31 9 33 10 73 11 12 12 10 13 100 14 95 15 46 16 65 17 47 18 22 19 25 \n0 25 1 8 2 34 3 96 4 66 5 73 6 11 7 20 8 38 9 38 10 80 11 18 12 62 13 63 14 89 15 63 16 70 17 1 18 31 19 17 \n0 9 1 79 2 64 3 61 4 84 5 43 6 30 7 48 8 100 9 94 10 12 11 10 12 33 13 58 14 72 15 33 16 69 17 87 18 71 19 71 \n0 72 1 16 2 29 3 67 4 72 5 98 6 70 7 2 8 37 9 86 10 57 11 90 12 8 13 31 14 48 15 59 16 29 17 76 18 9 19 72 \n0 97 1 13 2 87 3 22 4 75 5 31 6 70 7 82 8 99 9 56 10 79 11 45 12 49 13 17 14 68 15 75 16 94 17 21 18 62 19 66 \n0 70 1 66 2 16 3 92 4 83 5 91 6 79 7 40 8 88 9 51 10 20 11 87 12 14 13 30 14 80 15 78 16 11 17 75 18 11 19 45 \n" }, { "path": "examples/user_fssp_gls/TrainingData/15.txt", "content": "50 14\n0 47 1 86 2 77 3 82 4 21 5 19 6 33 7 40 8 77 9 82 10 69 11 35 12 45 13 77 \n0 94 1 44 2 71 3 25 4 37 5 66 6 20 7 10 8 86 9 65 10 53 11 49 12 26 13 90 \n0 12 1 93 2 23 3 47 4 93 5 85 6 68 7 42 8 91 9 76 10 1 11 60 12 26 13 80 \n0 59 1 17 2 36 3 15 4 69 5 21 6 75 7 40 8 61 9 95 10 60 11 10 12 85 13 82 \n0 50 1 88 2 21 3 36 4 59 5 82 6 67 7 25 8 25 9 19 10 96 11 24 12 14 13 15 \n0 78 1 81 2 80 3 42 4 88 5 10 6 92 7 82 8 89 9 83 10 92 11 92 12 33 13 37 \n0 17 1 3 2 29 3 91 4 58 5 50 6 14 7 18 8 94 9 76 10 36 11 48 12 56 13 95 \n0 74 1 70 2 54 3 59 4 14 5 74 6 42 7 94 8 96 9 68 10 30 11 47 12 26 13 92 \n0 65 1 87 2 97 3 86 4 17 5 79 6 24 7 86 8 27 9 96 10 67 11 99 12 65 13 67 \n0 90 1 36 2 62 3 75 4 30 5 56 6 94 7 21 8 99 9 26 10 34 11 12 12 26 13 84 \n0 41 1 57 2 1 3 29 4 83 5 21 6 95 7 62 8 26 9 5 10 35 11 81 12 94 13 41 \n0 19 1 30 2 99 3 95 4 18 5 99 6 32 7 56 8 20 9 17 10 48 11 19 12 57 13 57 \n0 2 1 94 2 86 3 26 4 71 5 4 6 98 7 33 8 97 9 86 10 92 11 44 12 88 13 64 \n0 81 1 44 2 72 3 82 4 49 5 9 6 25 7 63 8 66 9 46 10 46 11 75 12 97 13 74 \n0 86 1 37 2 55 3 50 4 37 5 16 6 38 7 57 8 92 9 37 10 17 11 12 12 39 13 92 \n0 26 1 47 2 14 3 93 4 47 5 76 6 35 7 89 8 78 9 11 10 72 11 79 12 73 13 29 \n0 47 1 1 2 55 3 92 4 60 5 47 6 18 7 10 8 32 9 76 10 61 11 59 12 83 13 62 \n0 90 1 55 2 47 3 22 4 35 5 32 6 87 7 69 8 11 9 70 10 19 11 40 12 38 13 2 \n0 72 1 72 2 57 3 20 4 45 5 46 6 53 7 23 8 97 9 19 10 13 11 80 12 58 13 58 \n0 33 1 20 2 66 3 61 4 90 5 60 6 70 7 12 8 66 9 84 10 31 11 98 12 23 13 60 \n0 34 1 53 2 83 3 52 4 82 5 24 6 74 7 6 8 56 9 19 10 5 11 92 12 25 13 57 \n0 52 1 50 2 86 3 65 4 16 5 74 6 74 7 100 8 72 9 16 10 67 11 98 12 6 13 98 \n0 37 1 40 2 85 3 20 4 83 5 34 6 3 7 61 8 21 9 48 10 11 11 21 12 70 13 26 \n0 52 1 21 2 9 3 27 4 60 5 31 6 64 7 18 8 34 9 15 10 53 11 29 12 53 13 21 \n0 76 1 81 2 21 3 5 4 24 5 51 6 100 7 22 8 25 9 42 10 98 11 97 12 70 13 80 \n0 34 1 55 2 61 3 15 4 57 5 86 6 5 7 90 8 38 9 11 10 31 11 16 12 43 13 67 \n0 55 1 90 2 34 3 44 4 36 5 24 6 72 7 40 8 75 9 96 10 96 11 89 12 97 13 100 \n0 12 1 65 2 22 3 62 4 46 5 82 6 26 7 55 8 61 9 25 10 5 11 5 12 61 13 55 \n0 55 1 96 2 76 3 89 4 2 5 94 6 65 7 19 8 93 9 1 10 95 11 38 12 77 13 60 \n0 7 1 99 2 46 3 95 4 3 5 42 6 71 7 80 8 1 9 58 10 30 11 25 12 2 13 12 \n0 9 1 42 2 87 3 4 4 52 5 87 6 2 7 80 8 70 9 61 10 3 11 74 12 47 13 11 \n0 36 1 96 2 18 3 82 4 66 5 15 6 41 7 11 8 90 9 25 10 80 11 68 12 10 13 26 \n0 25 1 47 2 9 3 76 4 1 5 31 6 83 7 20 8 98 9 2 10 52 11 5 12 85 13 53 \n0 89 1 13 2 44 3 26 4 26 5 97 6 78 7 28 8 13 9 15 10 21 11 28 12 46 13 83 \n0 93 1 27 2 9 3 85 4 12 5 22 6 19 7 13 8 88 9 75 10 4 11 17 12 87 13 35 \n0 67 1 45 2 40 3 60 4 13 5 19 6 46 7 76 8 22 9 64 10 65 11 4 12 57 13 21 \n0 53 1 10 2 42 3 51 4 90 5 92 6 14 7 81 8 2 9 4 10 60 11 80 12 15 13 26 \n0 89 1 26 2 12 3 74 4 75 5 39 6 90 7 70 8 43 9 88 10 69 11 65 12 71 13 27 \n0 1 1 61 2 37 3 13 4 81 5 91 6 73 7 19 8 9 9 67 10 35 11 87 12 2 13 30 \n0 72 1 82 2 80 3 7 4 85 5 97 6 84 7 68 8 14 9 86 10 79 11 2 12 75 13 8 \n0 72 1 19 2 3 3 58 4 57 5 73 6 15 7 22 8 72 9 17 10 3 11 10 12 86 13 29 \n0 71 1 70 2 20 3 85 4 33 5 29 6 80 7 17 8 62 9 12 10 35 11 55 12 93 13 32 \n0 89 1 68 2 12 3 30 4 100 5 74 6 24 7 47 8 98 9 28 10 36 11 56 12 20 13 32 \n0 38 1 63 2 63 3 18 4 56 5 39 6 68 7 36 8 72 9 9 10 81 11 67 12 80 13 30 \n0 96 1 85 2 42 3 49 4 80 5 49 6 67 7 30 8 58 9 64 10 95 11 68 12 28 13 5 \n0 32 1 5 2 22 3 20 4 70 5 28 6 64 7 42 8 18 9 13 10 14 11 5 12 92 13 51 \n0 36 1 49 2 68 3 39 4 41 5 36 6 72 7 14 8 88 9 24 10 47 11 46 12 71 13 32 \n0 97 1 96 2 66 3 17 4 20 5 59 6 3 7 78 8 89 9 27 10 71 11 10 12 5 13 13 \n0 25 1 89 2 42 3 82 4 18 5 25 6 80 7 97 8 71 9 1 10 33 11 65 12 17 13 22 \n0 48 1 10 2 83 3 82 4 33 5 11 6 30 7 33 8 66 9 27 10 73 11 34 12 44 13 96 \n" }, { "path": "examples/user_fssp_gls/TrainingData/16.txt", "content": "50 2\n0 65 1 19 \n0 60 1 83 \n0 32 1 68 \n0 3 1 6 \n0 75 1 73 \n0 5 1 12 \n0 60 1 53 \n0 39 1 95 \n0 93 1 4 \n0 39 1 25 \n0 39 1 90 \n0 65 1 66 \n0 53 1 50 \n0 34 1 43 \n0 29 1 60 \n0 98 1 83 \n0 39 1 64 \n0 3 1 62 \n0 33 1 16 \n0 42 1 94 \n0 30 1 89 \n0 69 1 63 \n0 86 1 57 \n0 72 1 92 \n0 74 1 6 \n0 90 1 2 \n0 61 1 33 \n0 21 1 41 \n0 87 1 82 \n0 22 1 64 \n0 96 1 4 \n0 83 1 30 \n0 94 1 4 \n0 91 1 84 \n0 65 1 5 \n0 47 1 28 \n0 2 1 32 \n0 72 1 70 \n0 32 1 10 \n0 80 1 44 \n0 51 1 23 \n0 30 1 73 \n0 88 1 81 \n0 95 1 95 \n0 78 1 100 \n0 32 1 1 \n0 13 1 98 \n0 48 1 78 \n0 18 1 39 \n0 85 1 61 \n" }, { "path": "examples/user_fssp_gls/TrainingData/17.txt", "content": "50 20\n0 76 1 35 2 39 3 42 4 98 5 49 6 11 7 60 8 93 9 75 10 64 11 10 12 11 13 28 14 60 15 28 16 48 17 31 18 45 19 86 \n0 33 1 16 2 18 3 43 4 76 5 12 6 35 7 71 8 64 9 8 10 88 11 59 12 25 13 7 14 11 15 79 16 46 17 93 18 91 19 73 \n0 100 1 84 2 39 3 74 4 31 5 65 6 86 7 34 8 21 9 47 10 52 11 75 12 74 13 15 14 88 15 11 16 92 17 30 18 99 19 87 \n0 44 1 20 2 53 3 91 4 61 5 48 6 54 7 39 8 71 9 61 10 54 11 66 12 14 13 56 14 93 15 14 16 82 17 90 18 65 19 2 \n0 6 1 86 2 21 3 7 4 34 5 13 6 97 7 91 8 75 9 86 10 83 11 79 12 35 13 68 14 98 15 28 16 78 17 65 18 96 19 22 \n0 95 1 70 2 57 3 22 4 52 5 37 6 21 7 76 8 1 9 29 10 62 11 82 12 72 13 47 14 21 15 98 16 12 17 13 18 40 19 8 \n0 47 1 78 2 90 3 5 4 19 5 15 6 72 7 55 8 99 9 59 10 100 11 14 12 22 13 35 14 46 15 29 16 70 17 9 18 65 19 99 \n0 83 1 95 2 96 3 75 4 90 5 87 6 45 7 93 8 19 9 88 10 5 11 25 12 20 13 88 14 69 15 89 16 22 17 95 18 40 19 69 \n0 17 1 84 2 12 3 38 4 32 5 19 6 45 7 19 8 64 9 19 10 89 11 89 12 90 13 56 14 16 15 92 16 4 17 70 18 9 19 63 \n0 93 1 62 2 87 3 92 4 4 5 81 6 57 7 74 8 82 9 49 10 3 11 34 12 53 13 84 14 50 15 48 16 24 17 74 18 57 19 13 \n0 6 1 73 2 15 3 79 4 5 5 77 6 60 7 40 8 58 9 15 10 6 11 30 12 30 13 84 14 30 15 71 16 90 17 27 18 56 19 2 \n0 16 1 63 2 55 3 47 4 47 5 99 6 70 7 76 8 60 9 32 10 39 11 7 12 64 13 59 14 15 15 30 16 1 17 38 18 69 19 69 \n0 62 1 67 2 58 3 8 4 13 5 70 6 84 7 48 8 59 9 1 10 73 11 57 12 38 13 31 14 15 15 53 16 93 17 59 18 5 19 1 \n0 46 1 78 2 57 3 100 4 60 5 67 6 35 7 64 8 15 9 2 10 30 11 85 12 6 13 87 14 88 15 45 16 57 17 84 18 22 19 34 \n0 81 1 92 2 62 3 87 4 97 5 90 6 79 7 82 8 39 9 38 10 14 11 17 12 50 13 70 14 47 15 89 16 75 17 23 18 16 19 93 \n0 71 1 52 2 99 3 23 4 8 5 88 6 51 7 45 8 4 9 69 10 100 11 25 12 61 13 15 14 73 15 91 16 7 17 16 18 66 19 85 \n0 4 1 98 2 47 3 70 4 74 5 56 6 76 7 47 8 55 9 21 10 67 11 8 12 44 13 16 14 72 15 69 16 87 17 2 18 74 19 76 \n0 11 1 75 2 69 3 1 4 36 5 4 6 44 7 58 8 70 9 98 10 72 11 25 12 24 13 7 14 50 15 65 16 13 17 14 18 78 19 53 \n0 63 1 88 2 79 3 74 4 90 5 10 6 63 7 22 8 97 9 8 10 88 11 64 12 70 13 29 14 32 15 35 16 59 17 29 18 88 19 85 \n0 47 1 99 2 37 3 21 4 84 5 32 6 76 7 97 8 25 9 38 10 77 11 5 12 37 13 11 14 64 15 20 16 4 17 89 18 93 19 75 \n0 83 1 6 2 30 3 96 4 25 5 17 6 53 7 69 8 10 9 53 10 17 11 7 12 31 13 16 14 67 15 37 16 62 17 54 18 68 19 86 \n0 18 1 87 2 43 3 69 4 8 5 81 6 26 7 69 8 42 9 88 10 11 11 1 12 4 13 31 14 51 15 52 16 97 17 5 18 48 19 81 \n0 61 1 75 2 82 3 68 4 36 5 77 6 19 7 77 8 77 9 83 10 80 11 64 12 90 13 23 14 57 15 100 16 86 17 1 18 20 19 15 \n0 26 1 71 2 98 3 11 4 73 5 90 6 46 7 60 8 14 9 63 10 6 11 53 12 40 13 65 14 3 15 23 16 28 17 58 18 84 19 9 \n0 8 1 80 2 62 3 34 4 8 5 4 6 15 7 99 8 32 9 89 10 49 11 15 12 87 13 45 14 58 15 36 16 68 17 14 18 88 19 14 \n0 34 1 57 2 88 3 3 4 61 5 79 6 56 7 47 8 92 9 47 10 86 11 7 12 79 13 95 14 58 15 31 16 53 17 61 18 83 19 44 \n0 43 1 11 2 7 3 61 4 32 5 32 6 1 7 81 8 80 9 85 10 65 11 51 12 90 13 94 14 38 15 67 16 53 17 76 18 35 19 86 \n0 95 1 14 2 94 3 90 4 29 5 54 6 42 7 32 8 18 9 53 10 49 11 15 12 80 13 82 14 63 15 63 16 33 17 20 18 84 19 99 \n0 19 1 85 2 50 3 96 4 17 5 8 6 93 7 75 8 8 9 50 10 16 11 52 12 4 13 36 14 2 15 77 16 12 17 85 18 2 19 79 \n0 88 1 35 2 35 3 59 4 29 5 81 6 25 7 5 8 66 9 24 10 45 11 85 12 33 13 81 14 9 15 46 16 18 17 68 18 59 19 86 \n0 14 1 99 2 55 3 4 4 73 5 80 6 9 7 16 8 14 9 64 10 39 11 69 12 30 13 77 14 86 15 83 16 39 17 4 18 47 19 2 \n0 24 1 60 2 65 3 42 4 28 5 89 6 41 7 38 8 79 9 33 10 81 11 61 12 2 13 72 14 29 15 76 16 86 17 36 18 47 19 88 \n0 80 1 78 2 90 3 73 4 78 5 87 6 53 7 48 8 21 9 71 10 34 11 4 12 33 13 57 14 96 15 3 16 78 17 97 18 40 19 14 \n0 93 1 50 2 11 3 45 4 93 5 67 6 89 7 26 8 77 9 41 10 13 11 75 12 60 13 8 14 14 15 88 16 21 17 55 18 10 19 72 \n0 83 1 47 2 4 3 39 4 83 5 21 6 37 7 28 8 28 9 19 10 1 11 95 12 1 13 1 14 88 15 77 16 90 17 30 18 98 19 21 \n0 87 1 24 2 4 3 22 4 97 5 44 6 68 7 98 8 3 9 2 10 38 11 21 12 25 13 81 14 83 15 76 16 27 17 36 18 1 19 45 \n0 45 1 78 2 41 3 62 4 62 5 95 6 21 7 78 8 77 9 93 10 35 11 18 12 99 13 3 14 17 15 33 16 28 17 95 18 32 19 71 \n0 94 1 16 2 19 3 65 4 65 5 91 6 14 7 47 8 42 9 100 10 39 11 66 12 79 13 69 14 73 15 66 16 9 17 33 18 58 19 82 \n0 2 1 93 2 34 3 62 4 14 5 20 6 19 7 83 8 35 9 72 10 97 11 39 12 32 13 41 14 54 15 44 16 7 17 13 18 38 19 100 \n0 41 1 90 2 65 3 19 4 61 5 55 6 6 7 11 8 50 9 78 10 27 11 24 12 54 13 59 14 41 15 69 16 99 17 39 18 5 19 4 \n0 64 1 28 2 94 3 26 4 1 5 53 6 78 7 61 8 27 9 38 10 65 11 30 12 78 13 85 14 7 15 53 16 94 17 21 18 60 19 8 \n0 12 1 39 2 78 3 93 4 29 5 77 6 85 7 88 8 44 9 91 10 78 11 77 12 75 13 90 14 17 15 29 16 70 17 77 18 83 19 28 \n0 6 1 6 2 45 3 80 4 91 5 67 6 13 7 33 8 67 9 9 10 70 11 38 12 29 13 99 14 22 15 40 16 28 17 31 18 26 19 51 \n0 84 1 25 2 55 3 98 4 39 5 17 6 62 7 71 8 72 9 50 10 73 11 21 12 74 13 75 14 33 15 94 16 4 17 35 18 100 19 38 \n0 20 1 17 2 97 3 83 4 91 5 22 6 1 7 85 8 7 9 82 10 14 11 96 12 66 13 30 14 46 15 19 16 32 17 91 18 65 19 91 \n0 12 1 45 2 62 3 31 4 48 5 20 6 67 7 93 8 93 9 37 10 33 11 6 12 49 13 13 14 62 15 96 16 18 17 23 18 19 19 1 \n0 73 1 43 2 54 3 97 4 65 5 2 6 36 7 95 8 52 9 12 10 13 11 69 12 44 13 29 14 25 15 94 16 73 17 13 18 66 19 78 \n0 43 1 1 2 5 3 30 4 49 5 12 6 80 7 85 8 99 9 18 10 51 11 52 12 98 13 53 14 2 15 85 16 7 17 26 18 90 19 65 \n0 39 1 71 2 6 3 58 4 5 5 51 6 98 7 72 8 56 9 98 10 99 11 29 12 98 13 67 14 66 15 13 16 72 17 65 18 49 19 29 \n0 41 1 10 2 60 3 93 4 5 5 4 6 13 7 55 8 74 9 18 10 8 11 62 12 9 13 37 14 33 15 48 16 10 17 84 18 17 19 7 \n" }, { "path": "examples/user_fssp_gls/TrainingData/18.txt", "content": "50 6\n0 58 1 85 2 44 3 5 4 71 5 98 \n0 30 1 57 2 69 3 27 4 65 5 92 \n0 22 1 43 2 26 3 75 4 70 5 100 \n0 71 1 90 2 52 3 39 4 34 5 41 \n0 12 1 8 2 9 3 91 4 97 5 72 \n0 29 1 25 2 61 3 72 4 34 5 62 \n0 90 1 45 2 4 3 22 4 85 5 26 \n0 88 1 12 2 59 3 41 4 30 5 14 \n0 34 1 15 2 24 3 48 4 76 5 73 \n0 55 1 57 2 87 3 79 4 78 5 12 \n0 11 1 97 2 37 3 97 4 8 5 95 \n0 96 1 3 2 100 3 77 4 75 5 18 \n0 84 1 61 2 58 3 68 4 78 5 47 \n0 26 1 35 2 57 3 48 4 2 5 65 \n0 71 1 55 2 77 3 48 4 53 5 22 \n0 20 1 78 2 63 3 33 4 8 5 83 \n0 9 1 49 2 60 3 54 4 26 5 81 \n0 66 1 4 2 20 3 40 4 50 5 40 \n0 7 1 15 2 36 3 60 4 69 5 81 \n0 17 1 63 2 60 3 39 4 16 5 42 \n0 55 1 56 2 1 3 66 4 91 5 72 \n0 26 1 95 2 57 3 77 4 14 5 56 \n0 84 1 69 2 93 3 65 4 66 5 40 \n0 17 1 64 2 49 3 37 4 1 5 62 \n0 89 1 56 2 59 3 72 4 29 5 57 \n0 55 1 82 2 51 3 96 4 99 5 65 \n0 79 1 71 2 38 3 70 4 38 5 14 \n0 9 1 48 2 49 3 52 4 79 5 96 \n0 11 1 29 2 84 3 3 4 7 5 62 \n0 19 1 89 2 57 3 78 4 69 5 14 \n0 4 1 54 2 8 3 87 4 62 5 78 \n0 8 1 87 2 77 3 12 4 83 5 64 \n0 6 1 40 2 24 3 85 4 74 5 7 \n0 58 1 19 2 44 3 29 4 34 5 82 \n0 77 1 44 2 79 3 17 4 78 5 22 \n0 18 1 91 2 59 3 51 4 13 5 37 \n0 97 1 87 2 10 3 31 4 58 5 32 \n0 23 1 56 2 71 3 87 4 65 5 100 \n0 82 1 90 2 50 3 96 4 87 5 19 \n0 89 1 86 2 2 3 54 4 3 5 92 \n0 29 1 77 2 8 3 94 4 11 5 56 \n0 45 1 35 2 14 3 74 4 39 5 99 \n0 36 1 76 2 31 3 65 4 46 5 52 \n0 88 1 59 2 85 3 72 4 20 5 50 \n0 8 1 70 2 92 3 61 4 7 5 43 \n0 19 1 86 2 63 3 34 4 46 5 44 \n0 36 1 61 2 10 3 5 4 21 5 31 \n0 62 1 16 2 95 3 39 4 81 5 43 \n0 27 1 19 2 93 3 7 4 99 5 99 \n0 26 1 23 2 51 3 17 4 67 5 2 \n" }, { "path": "examples/user_fssp_gls/TrainingData/19.txt", "content": "50 19\n0 90 1 83 2 55 3 75 4 15 5 95 6 11 7 39 8 26 9 51 10 76 11 27 12 50 13 5 14 35 15 64 16 33 17 62 18 59 \n0 69 1 27 2 43 3 18 4 29 5 72 6 19 7 32 8 63 9 49 10 73 11 83 12 18 13 11 14 46 15 12 16 74 17 63 18 84 \n0 39 1 91 2 30 3 98 4 11 5 56 6 40 7 92 8 40 9 70 10 94 11 8 12 84 13 36 14 97 15 77 16 12 17 53 18 72 \n0 71 1 76 2 48 3 73 4 78 5 74 6 85 7 53 8 85 9 51 10 36 11 15 12 38 13 9 14 25 15 34 16 68 17 65 18 95 \n0 51 1 95 2 30 3 71 4 42 5 56 6 40 7 52 8 63 9 8 10 83 11 4 12 9 13 19 14 99 15 6 16 39 17 39 18 56 \n0 59 1 33 2 91 3 74 4 94 5 54 6 98 7 64 8 62 9 85 10 84 11 76 12 56 13 60 14 25 15 38 16 87 17 18 18 25 \n0 14 1 80 2 96 3 30 4 56 5 74 6 35 7 82 8 13 9 97 10 25 11 97 12 18 13 21 14 60 15 59 16 5 17 25 18 10 \n0 12 1 98 2 21 3 96 4 95 5 1 6 13 7 30 8 57 9 4 10 28 11 36 12 53 13 31 14 50 15 37 16 35 17 95 18 87 \n0 18 1 22 2 76 3 49 4 7 5 76 6 97 7 80 8 10 9 80 10 59 11 16 12 63 13 10 14 41 15 18 16 17 17 86 18 93 \n0 80 1 52 2 86 3 33 4 67 5 41 6 56 7 45 8 32 9 45 10 56 11 40 12 100 13 19 14 97 15 71 16 80 17 88 18 63 \n0 27 1 27 2 68 3 52 4 49 5 88 6 27 7 8 8 21 9 98 10 26 11 46 12 37 13 88 14 60 15 84 16 38 17 81 18 85 \n0 17 1 38 2 33 3 14 4 61 5 88 6 93 7 92 8 78 9 14 10 54 11 4 12 37 13 72 14 86 15 84 16 21 17 83 18 42 \n0 87 1 17 2 5 3 7 4 85 5 8 6 8 7 3 8 36 9 71 10 42 11 48 12 21 13 85 14 3 15 50 16 13 17 5 18 44 \n0 81 1 78 2 56 3 16 4 36 5 24 6 26 7 10 8 89 9 64 10 47 11 24 12 19 13 51 14 27 15 61 16 28 17 27 18 66 \n0 59 1 47 2 78 3 76 4 53 5 83 6 74 7 75 8 30 9 26 10 10 11 23 12 43 13 43 14 67 15 19 16 79 17 81 18 78 \n0 46 1 94 2 97 3 31 4 57 5 76 6 55 7 23 8 44 9 28 10 78 11 73 12 15 13 56 14 70 15 35 16 59 17 6 18 61 \n0 47 1 2 2 48 3 87 4 46 5 16 6 72 7 71 8 30 9 89 10 82 11 81 12 46 13 25 14 69 15 67 16 10 17 24 18 37 \n0 3 1 31 2 22 3 97 4 85 5 84 6 43 7 86 8 1 9 76 10 33 11 49 12 53 13 26 14 40 15 31 16 21 17 72 18 99 \n0 43 1 19 2 15 3 83 4 81 5 5 6 91 7 8 8 51 9 28 10 31 11 55 12 84 13 70 14 66 15 6 16 83 17 71 18 68 \n0 35 1 5 2 91 3 54 4 17 5 30 6 54 7 91 8 10 9 68 10 2 11 57 12 5 13 6 14 13 15 48 16 82 17 76 18 31 \n0 40 1 71 2 2 3 36 4 16 5 75 6 91 7 91 8 20 9 65 10 35 11 4 12 99 13 54 14 11 15 99 16 25 17 45 18 50 \n0 78 1 88 2 26 3 84 4 26 5 8 6 81 7 86 8 83 9 50 10 65 11 65 12 96 13 100 14 19 15 64 16 46 17 26 18 51 \n0 82 1 21 2 39 3 14 4 16 5 49 6 90 7 35 8 65 9 79 10 56 11 25 12 64 13 19 14 39 15 48 16 59 17 83 18 63 \n0 97 1 90 2 53 3 48 4 82 5 46 6 8 7 21 8 26 9 53 10 30 11 72 12 46 13 19 14 66 15 91 16 72 17 43 18 93 \n0 57 1 61 2 93 3 39 4 69 5 46 6 64 7 18 8 47 9 76 10 87 11 22 12 44 13 10 14 29 15 10 16 39 17 42 18 16 \n0 20 1 77 2 28 3 26 4 6 5 41 6 37 7 9 8 46 9 70 10 65 11 48 12 14 13 76 14 31 15 80 16 21 17 4 18 13 \n0 17 1 43 2 60 3 4 4 51 5 69 6 7 7 49 8 18 9 47 10 10 11 39 12 95 13 25 14 66 15 61 16 84 17 94 18 29 \n0 60 1 39 2 1 3 68 4 49 5 27 6 8 7 27 8 38 9 73 10 5 11 4 12 22 13 27 14 23 15 8 16 18 17 3 18 99 \n0 22 1 1 2 42 3 23 4 75 5 37 6 24 7 45 8 11 9 27 10 3 11 56 12 88 13 16 14 98 15 26 16 65 17 75 18 44 \n0 10 1 79 2 72 3 70 4 24 5 80 6 86 7 9 8 83 9 74 10 14 11 92 12 55 13 16 14 88 15 94 16 97 17 75 18 68 \n0 65 1 57 2 45 3 70 4 54 5 34 6 86 7 49 8 71 9 73 10 15 11 32 12 66 13 11 14 14 15 82 16 30 17 45 18 69 \n0 51 1 97 2 92 3 43 4 2 5 95 6 7 7 1 8 56 9 72 10 8 11 5 12 41 13 56 14 2 15 68 16 62 17 33 18 10 \n0 49 1 10 2 26 3 73 4 74 5 71 6 70 7 69 8 42 9 58 10 12 11 31 12 43 13 52 14 87 15 65 16 54 17 12 18 96 \n0 86 1 1 2 100 3 81 4 86 5 72 6 30 7 24 8 27 9 43 10 61 11 79 12 12 13 9 14 76 15 85 16 68 17 22 18 100 \n0 31 1 63 2 14 3 88 4 99 5 100 6 98 7 38 8 19 9 62 10 1 11 66 12 70 13 72 14 13 15 60 16 17 17 18 18 17 \n0 4 1 40 2 11 3 3 4 24 5 32 6 94 7 72 8 84 9 16 10 5 11 36 12 28 13 94 14 30 15 34 16 58 17 6 18 80 \n0 59 1 33 2 87 3 66 4 26 5 97 6 15 7 36 8 96 9 21 10 68 11 82 12 81 13 87 14 33 15 89 16 99 17 28 18 72 \n0 35 1 52 2 23 3 66 4 58 5 37 6 33 7 23 8 89 9 90 10 43 11 34 12 36 13 79 14 21 15 43 16 58 17 100 18 91 \n0 25 1 14 2 34 3 93 4 26 5 4 6 31 7 45 8 42 9 66 10 8 11 9 12 90 13 9 14 89 15 81 16 4 17 47 18 25 \n0 48 1 57 2 40 3 23 4 3 5 22 6 81 7 96 8 48 9 25 10 4 11 77 12 23 13 87 14 86 15 96 16 59 17 2 18 67 \n0 23 1 67 2 76 3 7 4 33 5 41 6 25 7 67 8 49 9 67 10 55 11 82 12 51 13 57 14 78 15 19 16 91 17 63 18 38 \n0 62 1 21 2 6 3 40 4 45 5 8 6 40 7 87 8 72 9 41 10 14 11 47 12 89 13 74 14 60 15 55 16 78 17 13 18 78 \n0 33 1 92 2 54 3 69 4 55 5 90 6 61 7 38 8 11 9 3 10 83 11 55 12 28 13 7 14 20 15 65 16 65 17 11 18 9 \n0 44 1 38 2 23 3 50 4 43 5 77 6 64 7 62 8 37 9 22 10 42 11 13 12 70 13 17 14 29 15 88 16 54 17 91 18 2 \n0 94 1 5 2 38 3 73 4 20 5 6 6 91 7 16 8 26 9 44 10 24 11 67 12 28 13 71 14 74 15 33 16 4 17 69 18 82 \n0 71 1 96 2 21 3 4 4 100 5 98 6 77 7 78 8 85 9 4 10 54 11 9 12 8 13 92 14 55 15 18 16 97 17 83 18 74 \n0 10 1 67 2 14 3 5 4 39 5 84 6 20 7 70 8 91 9 31 10 56 11 21 12 64 13 87 14 77 15 3 16 36 17 100 18 38 \n0 20 1 73 2 77 3 73 4 14 5 55 6 96 7 18 8 74 9 25 10 9 11 41 12 53 13 96 14 7 15 6 16 49 17 44 18 99 \n0 94 1 30 2 13 3 52 4 6 5 15 6 51 7 8 8 6 9 8 10 34 11 1 12 51 13 49 14 46 15 56 16 41 17 55 18 96 \n0 59 1 19 2 5 3 80 4 7 5 65 6 100 7 38 8 46 9 61 10 83 11 44 12 9 13 74 14 91 15 95 16 80 17 85 18 34 \n" }, { "path": "examples/user_fssp_gls/TrainingData/2.txt", "content": "50 13\n0 49 1 34 2 32 3 53 4 93 5 4 6 62 7 30 8 73 9 60 10 33 11 63 12 76 \n0 36 1 62 2 4 3 94 4 61 5 18 6 13 7 57 8 59 9 98 10 93 11 43 12 18 \n0 32 1 58 2 65 3 23 4 9 5 52 6 7 7 73 8 92 9 82 10 65 11 84 12 63 \n0 29 1 69 2 41 3 44 4 23 5 54 6 49 7 51 8 39 9 52 10 2 11 40 12 15 \n0 28 1 68 2 6 3 79 4 84 5 74 6 50 7 67 8 28 9 39 10 2 11 44 12 29 \n0 33 1 100 2 24 3 32 4 28 5 34 6 88 7 89 8 40 9 28 10 71 11 59 12 57 \n0 88 1 100 2 9 3 65 4 51 5 33 6 85 7 76 8 16 9 7 10 4 11 69 12 63 \n0 45 1 29 2 47 3 2 4 38 5 65 6 20 7 25 8 65 9 91 10 68 11 45 12 62 \n0 78 1 69 2 46 3 88 4 32 5 63 6 6 7 2 8 34 9 43 10 89 11 12 12 5 \n0 89 1 45 2 87 3 78 4 77 5 60 6 16 7 67 8 68 9 14 10 4 11 90 12 65 \n0 29 1 64 2 50 3 60 4 27 5 83 6 17 7 57 8 38 9 34 10 31 11 60 12 86 \n0 18 1 72 2 14 3 59 4 50 5 95 6 36 7 99 8 19 9 73 10 50 11 30 12 66 \n0 90 1 70 2 71 3 80 4 84 5 16 6 100 7 12 8 52 9 79 10 4 11 54 12 34 \n0 32 1 81 2 87 3 11 4 35 5 63 6 93 7 83 8 3 9 1 10 39 11 97 12 44 \n0 86 1 37 2 14 3 54 4 92 5 71 6 19 7 42 8 58 9 63 10 72 11 84 12 94 \n0 90 1 60 2 73 3 22 4 83 5 13 6 84 7 40 8 88 9 32 10 54 11 72 12 26 \n0 10 1 88 2 46 3 17 4 87 5 95 6 10 7 26 8 14 9 13 10 94 11 92 12 32 \n0 57 1 88 2 92 3 85 4 60 5 30 6 40 7 67 8 31 9 34 10 9 11 18 12 30 \n0 17 1 100 2 67 3 67 4 20 5 49 6 54 7 62 8 98 9 29 10 80 11 37 12 21 \n0 49 1 52 2 19 3 37 4 74 5 83 6 13 7 16 8 12 9 14 10 91 11 11 12 6 \n0 48 1 80 2 13 3 37 4 64 5 66 6 36 7 79 8 78 9 76 10 87 11 20 12 76 \n0 25 1 15 2 25 3 60 4 64 5 86 6 83 7 47 8 56 9 50 10 24 11 51 12 90 \n0 89 1 3 2 10 3 73 4 49 5 32 6 47 7 24 8 89 9 34 10 72 11 1 12 80 \n0 22 1 41 2 31 3 34 4 56 5 56 6 90 7 94 8 93 9 31 10 15 11 34 12 36 \n0 1 1 50 2 77 3 90 4 71 5 93 6 58 7 52 8 87 9 40 10 79 11 23 12 6 \n0 90 1 100 2 49 3 44 4 87 5 38 6 5 7 93 8 80 9 47 10 53 11 61 12 43 \n0 62 1 86 2 56 3 27 4 65 5 4 6 38 7 6 8 46 9 60 10 46 11 33 12 97 \n0 94 1 99 2 95 3 34 4 8 5 67 6 88 7 19 8 43 9 56 10 72 11 63 12 35 \n0 13 1 95 2 90 3 38 4 46 5 14 6 23 7 12 8 88 9 37 10 92 11 20 12 16 \n0 77 1 65 2 50 3 23 4 71 5 9 6 62 7 48 8 83 9 86 10 75 11 85 12 44 \n0 28 1 95 2 13 3 75 4 38 5 51 6 41 7 100 8 45 9 11 10 42 11 24 12 97 \n0 58 1 6 2 68 3 17 4 51 5 85 6 87 7 16 8 44 9 55 10 7 11 31 12 85 \n0 17 1 13 2 100 3 27 4 6 5 5 6 3 7 60 8 90 9 100 10 10 11 11 12 73 \n0 85 1 72 2 83 3 78 4 37 5 47 6 64 7 23 8 52 9 82 10 34 11 49 12 8 \n0 64 1 21 2 17 3 30 4 73 5 21 6 92 7 4 8 71 9 16 10 55 11 95 12 86 \n0 6 1 42 2 33 3 3 4 1 5 83 6 68 7 68 8 83 9 75 10 37 11 40 12 99 \n0 49 1 43 2 76 3 59 4 53 5 47 6 29 7 25 8 83 9 30 10 30 11 67 12 34 \n0 70 1 27 2 58 3 52 4 11 5 15 6 3 7 91 8 69 9 24 10 57 11 17 12 3 \n0 81 1 16 2 7 3 90 4 73 5 66 6 75 7 68 8 81 9 9 10 66 11 60 12 10 \n0 31 1 57 2 40 3 56 4 6 5 37 6 87 7 54 8 52 9 1 10 92 11 86 12 70 \n0 61 1 14 2 10 3 92 4 15 5 89 6 11 7 35 8 72 9 54 10 5 11 70 12 96 \n0 5 1 42 2 15 3 100 4 92 5 16 6 4 7 58 8 15 9 92 10 29 11 21 12 51 \n0 46 1 55 2 90 3 90 4 41 5 17 6 31 7 19 8 56 9 55 10 80 11 77 12 45 \n0 55 1 62 2 48 3 61 4 45 5 31 6 4 7 74 8 60 9 36 10 14 11 84 12 52 \n0 97 1 59 2 16 3 92 4 43 5 66 6 82 7 16 8 14 9 22 10 33 11 33 12 1 \n0 48 1 28 2 13 3 61 4 11 5 63 6 62 7 51 8 33 9 26 10 70 11 17 12 21 \n0 92 1 32 2 89 3 57 4 68 5 7 6 65 7 81 8 66 9 78 10 32 11 17 12 13 \n0 86 1 34 2 25 3 31 4 53 5 14 6 8 7 2 8 61 9 82 10 1 11 51 12 76 \n0 90 1 32 2 19 3 71 4 90 5 55 6 62 7 62 8 77 9 43 10 100 11 7 12 99 \n0 78 1 63 2 30 3 51 4 7 5 90 6 12 7 96 8 27 9 10 10 87 11 67 12 6 \n" }, { "path": "examples/user_fssp_gls/TrainingData/20.txt", "content": "50 14\n0 45 1 69 2 21 3 36 4 89 5 54 6 71 7 79 8 37 9 28 10 32 11 53 12 92 13 9 \n0 36 1 65 2 67 3 50 4 62 5 59 6 68 7 92 8 33 9 86 10 77 11 5 12 98 13 4 \n0 18 1 5 2 85 3 71 4 94 5 55 6 19 7 2 8 80 9 69 10 85 11 17 12 22 13 96 \n0 31 1 83 2 37 3 76 4 13 5 1 6 96 7 37 8 2 9 71 10 87 11 62 12 47 13 98 \n0 46 1 44 2 6 3 39 4 68 5 59 6 76 7 72 8 34 9 30 10 9 11 94 12 2 13 42 \n0 42 1 56 2 92 3 70 4 11 5 24 6 55 7 81 8 47 9 94 10 59 11 6 12 25 13 19 \n0 20 1 65 2 23 3 2 4 58 5 84 6 22 7 85 8 58 9 78 10 34 11 74 12 44 13 36 \n0 60 1 39 2 63 3 89 4 66 5 85 6 17 7 86 8 30 9 4 10 65 11 78 12 86 13 69 \n0 66 1 93 2 68 3 13 4 73 5 67 6 29 7 97 8 68 9 80 10 41 11 81 12 10 13 82 \n0 65 1 87 2 54 3 51 4 38 5 96 6 83 7 81 8 3 9 4 10 27 11 11 12 62 13 90 \n0 43 1 97 2 33 3 12 4 21 5 27 6 73 7 96 8 73 9 19 10 30 11 1 12 24 13 19 \n0 63 1 46 2 41 3 16 4 34 5 84 6 78 7 87 8 83 9 75 10 26 11 21 12 8 13 13 \n0 77 1 74 2 98 3 57 4 80 5 87 6 86 7 6 8 30 9 89 10 35 11 18 12 7 13 13 \n0 79 1 39 2 8 3 50 4 17 5 42 6 58 7 57 8 68 9 57 10 66 11 70 12 100 13 21 \n0 63 1 83 2 29 3 61 4 77 5 83 6 64 7 61 8 76 9 20 10 99 11 67 12 60 13 48 \n0 8 1 95 2 87 3 93 4 40 5 20 6 80 7 39 8 91 9 65 10 61 11 83 12 77 13 75 \n0 19 1 2 2 35 3 53 4 69 5 23 6 2 7 26 8 29 9 92 10 78 11 60 12 97 13 32 \n0 45 1 49 2 99 3 62 4 18 5 30 6 81 7 36 8 92 9 88 10 40 11 54 12 21 13 93 \n0 17 1 77 2 88 3 100 4 67 5 79 6 38 7 82 8 10 9 91 10 55 11 5 12 66 13 87 \n0 26 1 79 2 44 3 1 4 16 5 99 6 97 7 100 8 70 9 2 10 58 11 3 12 14 13 97 \n0 52 1 87 2 20 3 6 4 6 5 72 6 42 7 14 8 16 9 83 10 1 11 50 12 26 13 62 \n0 69 1 96 2 87 3 23 4 36 5 4 6 45 7 8 8 19 9 20 10 49 11 37 12 83 13 6 \n0 10 1 77 2 42 3 25 4 50 5 74 6 58 7 21 8 56 9 50 10 58 11 4 12 30 13 5 \n0 35 1 43 2 9 3 43 4 11 5 15 6 18 7 63 8 35 9 74 10 27 11 12 12 73 13 84 \n0 55 1 69 2 57 3 67 4 11 5 41 6 50 7 23 8 38 9 39 10 19 11 13 12 50 13 30 \n0 92 1 4 2 7 3 28 4 80 5 73 6 77 7 6 8 72 9 48 10 70 11 31 12 68 13 51 \n0 2 1 21 2 92 3 77 4 8 5 46 6 88 7 36 8 83 9 39 10 12 11 55 12 21 13 83 \n0 62 1 23 2 70 3 14 4 60 5 34 6 15 7 24 8 24 9 91 10 98 11 16 12 7 13 42 \n0 80 1 43 2 29 3 79 4 83 5 15 6 47 7 11 8 22 9 6 10 43 11 39 12 93 13 56 \n0 25 1 27 2 47 3 3 4 79 5 55 6 82 7 75 8 68 9 87 10 80 11 27 12 87 13 95 \n0 37 1 35 2 3 3 19 4 26 5 60 6 65 7 67 8 93 9 21 10 7 11 65 12 85 13 55 \n0 90 1 43 2 85 3 20 4 74 5 87 6 43 7 97 8 95 9 57 10 12 11 71 12 21 13 84 \n0 86 1 89 2 35 3 19 4 85 5 49 6 23 7 19 8 85 9 5 10 96 11 90 12 100 13 81 \n0 60 1 38 2 48 3 3 4 44 5 44 6 71 7 48 8 70 9 93 10 53 11 51 12 78 13 21 \n0 36 1 66 2 72 3 45 4 23 5 58 6 65 7 14 8 71 9 58 10 33 11 72 12 30 13 84 \n0 83 1 24 2 9 3 76 4 74 5 69 6 96 7 10 8 92 9 66 10 9 11 97 12 86 13 3 \n0 1 1 13 2 64 3 84 4 88 5 48 6 52 7 77 8 60 9 21 10 68 11 18 12 6 13 47 \n0 78 1 95 2 74 3 89 4 50 5 78 6 93 7 62 8 95 9 30 10 63 11 15 12 97 13 59 \n0 72 1 77 2 85 3 36 4 15 5 48 6 8 7 86 8 39 9 2 10 85 11 95 12 97 13 10 \n0 53 1 16 2 84 3 18 4 40 5 24 6 4 7 83 8 62 9 70 10 17 11 20 12 1 13 35 \n0 16 1 25 2 55 3 6 4 85 5 98 6 65 7 38 8 63 9 39 10 95 11 48 12 97 13 29 \n0 87 1 7 2 67 3 51 4 70 5 15 6 34 7 16 8 84 9 77 10 41 11 41 12 27 13 49 \n0 88 1 65 2 85 3 6 4 32 5 31 6 50 7 65 8 34 9 32 10 33 11 25 12 27 13 17 \n0 54 1 79 2 28 3 90 4 9 5 29 6 11 7 22 8 73 9 17 10 35 11 90 12 66 13 66 \n0 95 1 66 2 30 3 50 4 20 5 66 6 72 7 51 8 39 9 59 10 14 11 63 12 65 13 27 \n0 31 1 31 2 21 3 13 4 6 5 98 6 39 7 21 8 44 9 21 10 27 11 99 12 81 13 32 \n0 92 1 47 2 26 3 33 4 100 5 13 6 11 7 14 8 11 9 66 10 70 11 18 12 91 13 83 \n0 26 1 24 2 3 3 43 4 62 5 21 6 8 7 55 8 67 9 31 10 83 11 26 12 63 13 17 \n0 27 1 86 2 47 3 98 4 93 5 46 6 6 7 36 8 2 9 42 10 67 11 23 12 74 13 55 \n0 20 1 9 2 67 3 68 4 61 5 48 6 32 7 32 8 77 9 25 10 6 11 14 12 11 13 49 \n" }, { "path": "examples/user_fssp_gls/TrainingData/21.txt", "content": "50 11\n0 41 1 34 2 73 3 16 4 79 5 11 6 26 7 94 8 81 9 20 10 28 \n0 82 1 52 2 68 3 40 4 86 5 99 6 44 7 81 8 73 9 81 10 58 \n0 16 1 3 2 86 3 29 4 75 5 25 6 39 7 88 8 42 9 61 10 95 \n0 90 1 78 2 5 3 61 4 54 5 37 6 99 7 30 8 47 9 96 10 34 \n0 69 1 58 2 44 3 91 4 70 5 11 6 78 7 6 8 20 9 87 10 91 \n0 37 1 96 2 90 3 50 4 90 5 78 6 30 7 77 8 48 9 89 10 73 \n0 84 1 95 2 21 3 94 4 55 5 81 6 89 7 77 8 82 9 46 10 84 \n0 78 1 54 2 42 3 56 4 72 5 61 6 27 7 72 8 59 9 62 10 56 \n0 48 1 72 2 91 3 85 4 99 5 80 6 37 7 86 8 27 9 78 10 75 \n0 51 1 83 2 59 3 18 4 49 5 19 6 19 7 93 8 95 9 75 10 59 \n0 88 1 95 2 98 3 73 4 56 5 59 6 9 7 63 8 50 9 65 10 69 \n0 27 1 54 2 24 3 47 4 31 5 10 6 78 7 32 8 13 9 97 10 5 \n0 21 1 17 2 98 3 81 4 62 5 73 6 38 7 50 8 59 9 38 10 12 \n0 78 1 55 2 2 3 13 4 17 5 100 6 53 7 66 8 36 9 23 10 60 \n0 77 1 32 2 84 3 93 4 69 5 2 6 94 7 56 8 65 9 60 10 20 \n0 33 1 40 2 90 3 12 4 15 5 49 6 97 7 63 8 82 9 91 10 14 \n0 10 1 64 2 79 3 80 4 5 5 69 6 65 7 85 8 82 9 50 10 32 \n0 17 1 74 2 86 3 70 4 35 5 10 6 65 7 13 8 16 9 7 10 29 \n0 36 1 78 2 42 3 93 4 12 5 46 6 70 7 53 8 6 9 60 10 85 \n0 24 1 51 2 73 3 51 4 15 5 46 6 14 7 54 8 89 9 20 10 35 \n0 76 1 58 2 77 3 94 4 49 5 26 6 44 7 40 8 24 9 78 10 86 \n0 31 1 32 2 78 3 71 4 87 5 52 6 45 7 60 8 17 9 1 10 30 \n0 26 1 7 2 94 3 8 4 14 5 9 6 18 7 24 8 15 9 59 10 75 \n0 53 1 15 2 10 3 17 4 71 5 33 6 64 7 70 8 46 9 33 10 47 \n0 28 1 89 2 48 3 61 4 32 5 20 6 37 7 40 8 1 9 53 10 61 \n0 50 1 94 2 40 3 84 4 12 5 32 6 65 7 66 8 20 9 98 10 53 \n0 82 1 75 2 6 3 11 4 18 5 43 6 10 7 75 8 96 9 60 10 6 \n0 44 1 74 2 47 3 15 4 5 5 21 6 56 7 93 8 58 9 79 10 81 \n0 12 1 17 2 63 3 77 4 63 5 70 6 29 7 44 8 4 9 71 10 21 \n0 50 1 68 2 42 3 50 4 61 5 23 6 83 7 87 8 99 9 25 10 79 \n0 27 1 41 2 35 3 14 4 83 5 95 6 37 7 6 8 85 9 72 10 66 \n0 61 1 32 2 82 3 9 4 10 5 9 6 28 7 26 8 66 9 16 10 23 \n0 13 1 6 2 14 3 26 4 58 5 26 6 28 7 75 8 92 9 61 10 73 \n0 5 1 38 2 46 3 35 4 21 5 17 6 98 7 41 8 13 9 82 10 25 \n0 38 1 1 2 22 3 77 4 36 5 15 6 38 7 82 8 53 9 27 10 83 \n0 26 1 47 2 76 3 7 4 77 5 18 6 95 7 63 8 31 9 45 10 34 \n0 91 1 42 2 70 3 41 4 20 5 71 6 10 7 91 8 26 9 22 10 91 \n0 43 1 18 2 24 3 55 4 59 5 94 6 59 7 72 8 16 9 95 10 82 \n0 44 1 85 2 1 3 53 4 86 5 12 6 80 7 2 8 89 9 66 10 30 \n0 56 1 83 2 75 3 99 4 50 5 38 6 58 7 56 8 68 9 25 10 24 \n0 41 1 56 2 1 3 20 4 67 5 25 6 75 7 53 8 56 9 28 10 50 \n0 28 1 29 2 65 3 100 4 52 5 18 6 62 7 26 8 94 9 10 10 5 \n0 28 1 87 2 54 3 99 4 79 5 27 6 11 7 38 8 36 9 99 10 20 \n0 30 1 43 2 77 3 93 4 42 5 90 6 91 7 10 8 72 9 76 10 75 \n0 41 1 89 2 61 3 69 4 17 5 61 6 75 7 50 8 48 9 40 10 100 \n0 21 1 6 2 93 3 52 4 53 5 80 6 52 7 32 8 41 9 4 10 43 \n0 46 1 97 2 74 3 97 4 86 5 16 6 88 7 11 8 32 9 5 10 50 \n0 95 1 7 2 56 3 82 4 44 5 66 6 14 7 13 8 71 9 38 10 56 \n0 18 1 70 2 53 3 55 4 97 5 59 6 96 7 67 8 30 9 60 10 79 \n0 95 1 48 2 73 3 54 4 33 5 45 6 39 7 14 8 64 9 60 10 79 \n" }, { "path": "examples/user_fssp_gls/TrainingData/22.txt", "content": "50 2\n0 19 1 36 \n0 24 1 63 \n0 96 1 82 \n0 64 1 55 \n0 71 1 26 \n0 10 1 92 \n0 27 1 16 \n0 2 1 55 \n0 54 1 56 \n0 91 1 65 \n0 59 1 87 \n0 59 1 90 \n0 92 1 1 \n0 75 1 88 \n0 19 1 83 \n0 40 1 9 \n0 68 1 55 \n0 38 1 8 \n0 15 1 93 \n0 70 1 22 \n0 59 1 76 \n0 4 1 94 \n0 23 1 31 \n0 25 1 4 \n0 6 1 70 \n0 15 1 1 \n0 34 1 9 \n0 23 1 68 \n0 7 1 82 \n0 53 1 76 \n0 87 1 46 \n0 48 1 19 \n0 28 1 63 \n0 13 1 28 \n0 64 1 37 \n0 91 1 55 \n0 46 1 34 \n0 37 1 7 \n0 95 1 97 \n0 71 1 76 \n0 61 1 68 \n0 62 1 23 \n0 81 1 75 \n0 88 1 100 \n0 62 1 71 \n0 73 1 4 \n0 80 1 10 \n0 42 1 72 \n0 41 1 37 \n0 35 1 62 \n" }, { "path": "examples/user_fssp_gls/TrainingData/23.txt", "content": "50 10\n0 7 1 70 2 52 3 73 4 2 5 18 6 8 7 68 8 47 9 43 \n0 90 1 50 2 11 3 22 4 36 5 9 6 95 7 6 8 89 9 14 \n0 31 1 50 2 1 3 89 4 65 5 96 6 89 7 74 8 71 9 94 \n0 60 1 56 2 86 3 54 4 67 5 97 6 58 7 10 8 92 9 43 \n0 21 1 94 2 50 3 1 4 16 5 90 6 12 7 29 8 66 9 67 \n0 27 1 32 2 26 3 81 4 61 5 52 6 60 7 91 8 75 9 18 \n0 75 1 36 2 49 3 10 4 30 5 39 6 76 7 32 8 15 9 52 \n0 8 1 46 2 52 3 28 4 40 5 83 6 74 7 5 8 23 9 64 \n0 93 1 96 2 48 3 87 4 88 5 62 6 84 7 11 8 49 9 73 \n0 10 1 77 2 99 3 79 4 76 5 1 6 35 7 9 8 34 9 26 \n0 43 1 8 2 10 3 81 4 28 5 5 6 11 7 59 8 95 9 17 \n0 38 1 76 2 41 3 97 4 70 5 45 6 74 7 21 8 52 9 59 \n0 20 1 55 2 25 3 74 4 9 5 80 6 96 7 1 8 99 9 37 \n0 43 1 43 2 81 3 86 4 48 5 65 6 77 7 46 8 59 9 16 \n0 55 1 61 2 70 3 27 4 59 5 62 6 34 7 70 8 78 9 65 \n0 80 1 60 2 98 3 37 4 28 5 31 6 47 7 48 8 48 9 87 \n0 69 1 77 2 55 3 77 4 23 5 79 6 60 7 33 8 25 9 35 \n0 78 1 74 2 73 3 26 4 10 5 82 6 63 7 100 8 31 9 19 \n0 51 1 73 2 83 3 9 4 58 5 90 6 1 7 97 8 35 9 48 \n0 91 1 3 2 69 3 9 4 63 5 15 6 38 7 28 8 54 9 92 \n0 57 1 42 2 84 3 89 4 48 5 89 6 68 7 97 8 53 9 1 \n0 67 1 87 2 52 3 51 4 50 5 69 6 12 7 57 8 39 9 39 \n0 37 1 7 2 69 3 16 4 69 5 68 6 32 7 22 8 32 9 87 \n0 46 1 27 2 30 3 24 4 89 5 54 6 94 7 86 8 23 9 10 \n0 87 1 26 2 76 3 50 4 12 5 90 6 59 7 25 8 99 9 23 \n0 31 1 78 2 79 3 23 4 81 5 24 6 60 7 77 8 96 9 69 \n0 66 1 39 2 29 3 11 4 49 5 73 6 27 7 43 8 86 9 5 \n0 78 1 75 2 14 3 70 4 16 5 69 6 90 7 98 8 78 9 2 \n0 15 1 7 2 7 3 7 4 31 5 67 6 33 7 68 8 47 9 9 \n0 10 1 23 2 48 3 37 4 19 5 21 6 13 7 100 8 72 9 36 \n0 70 1 54 2 26 3 58 4 83 5 81 6 27 7 33 8 79 9 85 \n0 78 1 36 2 84 3 99 4 84 5 81 6 93 7 81 8 93 9 12 \n0 98 1 18 2 74 3 28 4 62 5 70 6 6 7 1 8 1 9 26 \n0 17 1 99 2 87 3 73 4 22 5 24 6 52 7 67 8 91 9 100 \n0 42 1 72 2 47 3 36 4 75 5 18 6 70 7 37 8 85 9 51 \n0 19 1 58 2 3 3 28 4 12 5 2 6 57 7 29 8 66 9 19 \n0 75 1 76 2 79 3 29 4 44 5 52 6 68 7 48 8 39 9 99 \n0 3 1 12 2 59 3 35 4 70 5 98 6 20 7 79 8 52 9 90 \n0 89 1 82 2 34 3 58 4 77 5 92 6 100 7 58 8 21 9 58 \n0 81 1 85 2 30 3 37 4 58 5 92 6 91 7 24 8 16 9 64 \n0 35 1 67 2 82 3 15 4 61 5 82 6 49 7 5 8 97 9 100 \n0 91 1 8 2 74 3 15 4 37 5 16 6 12 7 98 8 15 9 84 \n0 14 1 50 2 3 3 5 4 80 5 63 6 97 7 79 8 63 9 11 \n0 21 1 8 2 13 3 49 4 41 5 36 6 86 7 84 8 67 9 25 \n0 31 1 19 2 41 3 42 4 90 5 27 6 84 7 34 8 75 9 97 \n0 30 1 21 2 30 3 50 4 93 5 44 6 35 7 5 8 2 9 38 \n0 55 1 88 2 51 3 18 4 58 5 77 6 7 7 22 8 26 9 72 \n0 91 1 76 2 67 3 79 4 70 5 37 6 36 7 22 8 67 9 10 \n0 21 1 97 2 54 3 13 4 69 5 81 6 1 7 11 8 89 9 88 \n0 82 1 87 2 96 3 50 4 78 5 79 6 17 7 67 8 42 9 67 \n" }, { "path": "examples/user_fssp_gls/TrainingData/24.txt", "content": "50 3\n0 93 1 10 2 51 \n0 46 1 65 2 31 \n0 44 1 27 2 95 \n0 69 1 66 2 67 \n0 83 1 81 2 75 \n0 69 1 88 2 95 \n0 45 1 63 2 79 \n0 17 1 48 2 21 \n0 56 1 95 2 67 \n0 56 1 5 2 1 \n0 72 1 66 2 88 \n0 8 1 72 2 36 \n0 94 1 12 2 26 \n0 65 1 87 2 31 \n0 59 1 79 2 4 \n0 56 1 88 2 90 \n0 59 1 19 2 83 \n0 75 1 85 2 58 \n0 87 1 93 2 9 \n0 98 1 79 2 56 \n0 53 1 96 2 44 \n0 62 1 28 2 16 \n0 40 1 56 2 59 \n0 98 1 90 2 58 \n0 37 1 31 2 65 \n0 4 1 64 2 50 \n0 86 1 56 2 34 \n0 46 1 83 2 75 \n0 46 1 22 2 49 \n0 48 1 47 2 2 \n0 32 1 86 2 87 \n0 60 1 15 2 12 \n0 67 1 77 2 41 \n0 58 1 11 2 90 \n0 67 1 83 2 98 \n0 43 1 4 2 17 \n0 20 1 33 2 27 \n0 96 1 75 2 14 \n0 15 1 50 2 75 \n0 11 1 68 2 71 \n0 26 1 97 2 16 \n0 53 1 99 2 6 \n0 73 1 97 2 46 \n0 49 1 90 2 91 \n0 99 1 23 2 58 \n0 17 1 74 2 19 \n0 65 1 25 2 5 \n0 1 1 5 2 6 \n0 41 1 97 2 95 \n0 13 1 58 2 40 \n" }, { "path": "examples/user_fssp_gls/TrainingData/25.txt", "content": "50 11\n0 74 1 68 2 68 3 23 4 59 5 12 6 33 7 93 8 66 9 52 10 66 \n0 61 1 31 2 24 3 79 4 16 5 62 6 32 7 12 8 100 9 98 10 87 \n0 72 1 18 2 37 3 38 4 100 5 11 6 27 7 97 8 13 9 45 10 37 \n0 15 1 24 2 90 3 93 4 42 5 34 6 96 7 66 8 69 9 100 10 22 \n0 37 1 64 2 1 3 13 4 27 5 59 6 62 7 30 8 51 9 94 10 84 \n0 76 1 45 2 94 3 3 4 61 5 47 6 85 7 86 8 85 9 94 10 77 \n0 12 1 61 2 74 3 18 4 70 5 96 6 67 7 60 8 80 9 80 10 22 \n0 67 1 4 2 36 3 51 4 19 5 31 6 14 7 72 8 24 9 81 10 13 \n0 57 1 44 2 48 3 70 4 82 5 66 6 20 7 51 8 83 9 88 10 17 \n0 33 1 59 2 95 3 79 4 69 5 65 6 22 7 81 8 43 9 84 10 100 \n0 68 1 13 2 67 3 89 4 74 5 26 6 55 7 88 8 49 9 42 10 34 \n0 68 1 2 2 38 3 74 4 84 5 57 6 56 7 87 8 66 9 37 10 25 \n0 74 1 34 2 89 3 6 4 6 5 85 6 82 7 38 8 91 9 50 10 49 \n0 93 1 67 2 59 3 8 4 36 5 54 6 76 7 84 8 100 9 59 10 50 \n0 100 1 93 2 24 3 55 4 97 5 52 6 44 7 70 8 56 9 90 10 19 \n0 49 1 30 2 71 3 55 4 54 5 98 6 28 7 86 8 85 9 80 10 44 \n0 43 1 99 2 11 3 50 4 94 5 63 6 100 7 83 8 54 9 66 10 29 \n0 64 1 73 2 48 3 66 4 16 5 22 6 79 7 75 8 54 9 98 10 62 \n0 54 1 75 2 78 3 90 4 77 5 17 6 75 7 12 8 27 9 12 10 43 \n0 95 1 97 2 11 3 49 4 57 5 12 6 2 7 76 8 2 9 81 10 40 \n0 30 1 65 2 65 3 56 4 46 5 22 6 33 7 89 8 23 9 84 10 35 \n0 60 1 6 2 26 3 45 4 65 5 67 6 19 7 37 8 38 9 55 10 87 \n0 48 1 49 2 10 3 34 4 96 5 12 6 3 7 8 8 20 9 71 10 77 \n0 91 1 37 2 50 3 68 4 43 5 71 6 1 7 50 8 98 9 5 10 51 \n0 86 1 60 2 71 3 71 4 64 5 15 6 51 7 9 8 28 9 12 10 20 \n0 73 1 20 2 15 3 49 4 26 5 80 6 9 7 74 8 66 9 28 10 20 \n0 23 1 67 2 79 3 50 4 50 5 98 6 38 7 34 8 53 9 62 10 53 \n0 92 1 59 2 36 3 71 4 46 5 27 6 86 7 61 8 76 9 57 10 98 \n0 89 1 24 2 71 3 100 4 69 5 65 6 47 7 94 8 45 9 45 10 55 \n0 14 1 43 2 80 3 13 4 96 5 25 6 44 7 65 8 62 9 38 10 62 \n0 74 1 8 2 26 3 20 4 93 5 55 6 63 7 21 8 34 9 5 10 84 \n0 23 1 53 2 73 3 25 4 25 5 69 6 18 7 38 8 45 9 61 10 70 \n0 98 1 69 2 95 3 96 4 15 5 83 6 22 7 25 8 57 9 35 10 14 \n0 32 1 89 2 51 3 4 4 45 5 93 6 79 7 95 8 39 9 63 10 30 \n0 4 1 13 2 62 3 54 4 41 5 13 6 5 7 63 8 32 9 95 10 21 \n0 67 1 70 2 67 3 37 4 30 5 21 6 94 7 41 8 71 9 82 10 90 \n0 93 1 24 2 80 3 70 4 31 5 34 6 46 7 13 8 64 9 31 10 28 \n0 32 1 73 2 79 3 5 4 35 5 85 6 57 7 73 8 43 9 62 10 40 \n0 38 1 56 2 11 3 92 4 83 5 68 6 94 7 53 8 2 9 41 10 11 \n0 19 1 34 2 70 3 68 4 14 5 17 6 18 7 71 8 91 9 96 10 50 \n0 61 1 1 2 59 3 24 4 63 5 64 6 87 7 99 8 72 9 9 10 10 \n0 75 1 73 2 98 3 53 4 63 5 22 6 12 7 52 8 41 9 63 10 97 \n0 89 1 82 2 32 3 74 4 85 5 45 6 72 7 42 8 67 9 67 10 84 \n0 98 1 18 2 24 3 60 4 55 5 19 6 94 7 39 8 18 9 97 10 43 \n0 2 1 20 2 31 3 11 4 85 5 85 6 29 7 56 8 32 9 16 10 91 \n0 24 1 39 2 43 3 11 4 46 5 96 6 93 7 1 8 95 9 86 10 21 \n0 30 1 72 2 93 3 51 4 16 5 77 6 74 7 66 8 34 9 15 10 40 \n0 5 1 13 2 22 3 91 4 64 5 12 6 89 7 43 8 80 9 39 10 34 \n0 29 1 44 2 14 3 81 4 31 5 49 6 93 7 77 8 1 9 12 10 69 \n0 97 1 18 2 89 3 36 4 95 5 18 6 78 7 89 8 86 9 50 10 60 \n" }, { "path": "examples/user_fssp_gls/TrainingData/26.txt", "content": "50 8\n0 60 1 37 2 100 3 64 4 31 5 71 6 96 7 22 \n0 24 1 32 2 78 3 36 4 48 5 90 6 4 7 21 \n0 39 1 86 2 71 3 74 4 15 5 94 6 81 7 41 \n0 35 1 48 2 55 3 26 4 17 5 66 6 58 7 37 \n0 50 1 17 2 86 3 36 4 28 5 79 6 68 7 92 \n0 2 1 94 2 54 3 84 4 4 5 86 6 41 7 77 \n0 34 1 82 2 99 3 81 4 74 5 34 6 39 7 65 \n0 87 1 95 2 69 3 37 4 42 5 43 6 67 7 12 \n0 10 1 1 2 13 3 29 4 64 5 64 6 12 7 13 \n0 74 1 33 2 46 3 42 4 34 5 18 6 99 7 6 \n0 95 1 33 2 99 3 63 4 6 5 19 6 20 7 65 \n0 76 1 92 2 30 3 21 4 65 5 34 6 71 7 4 \n0 95 1 10 2 2 3 95 4 66 5 66 6 25 7 95 \n0 23 1 52 2 59 3 40 4 75 5 13 6 93 7 74 \n0 95 1 1 2 94 3 69 4 27 5 39 6 39 7 2 \n0 79 1 34 2 16 3 77 4 79 5 1 6 30 7 72 \n0 42 1 37 2 18 3 44 4 29 5 98 6 40 7 50 \n0 48 1 9 2 7 3 33 4 93 5 73 6 36 7 88 \n0 62 1 63 2 5 3 96 4 45 5 96 6 93 7 34 \n0 41 1 56 2 29 3 29 4 41 5 41 6 20 7 61 \n0 17 1 7 2 40 3 76 4 27 5 1 6 11 7 81 \n0 92 1 59 2 100 3 4 4 37 5 92 6 92 7 76 \n0 24 1 94 2 2 3 8 4 63 5 90 6 76 7 93 \n0 41 1 97 2 5 3 76 4 3 5 75 6 3 7 12 \n0 58 1 22 2 1 3 97 4 54 5 94 6 95 7 44 \n0 27 1 89 2 31 3 81 4 23 5 64 6 64 7 10 \n0 95 1 10 2 73 3 50 4 69 5 21 6 34 7 5 \n0 16 1 31 2 23 3 14 4 58 5 29 6 49 7 3 \n0 66 1 17 2 74 3 59 4 85 5 18 6 5 7 62 \n0 25 1 67 2 24 3 100 4 30 5 9 6 4 7 46 \n0 19 1 63 2 11 3 18 4 99 5 99 6 32 7 3 \n0 37 1 31 2 22 3 35 4 43 5 3 6 41 7 38 \n0 73 1 36 2 22 3 27 4 39 5 73 6 50 7 37 \n0 2 1 88 2 58 3 30 4 78 5 66 6 81 7 30 \n0 54 1 86 2 53 3 95 4 19 5 30 6 63 7 87 \n0 17 1 85 2 70 3 54 4 62 5 53 6 67 7 55 \n0 25 1 34 2 78 3 24 4 13 5 99 6 22 7 87 \n0 87 1 18 2 55 3 94 4 62 5 79 6 45 7 15 \n0 95 1 9 2 8 3 78 4 81 5 37 6 11 7 79 \n0 78 1 38 2 1 3 7 4 42 5 26 6 34 7 15 \n0 52 1 8 2 24 3 100 4 92 5 79 6 96 7 11 \n0 63 1 69 2 82 3 1 4 48 5 82 6 49 7 60 \n0 21 1 31 2 13 3 80 4 49 5 91 6 28 7 75 \n0 5 1 42 2 33 3 14 4 67 5 65 6 84 7 1 \n0 74 1 71 2 93 3 76 4 94 5 53 6 35 7 20 \n0 34 1 59 2 96 3 40 4 46 5 30 6 4 7 46 \n0 69 1 92 2 23 3 44 4 64 5 96 6 37 7 27 \n0 35 1 29 2 79 3 41 4 46 5 41 6 96 7 96 \n0 84 1 62 2 46 3 22 4 21 5 34 6 62 7 7 \n0 34 1 58 2 34 3 93 4 71 5 31 6 9 7 50 \n" }, { "path": "examples/user_fssp_gls/TrainingData/27.txt", "content": "50 6\n0 91 1 78 2 30 3 21 4 27 5 79 \n0 3 1 57 2 95 3 28 4 60 5 65 \n0 86 1 11 2 12 3 45 4 93 5 38 \n0 74 1 27 2 4 3 39 4 48 5 12 \n0 96 1 46 2 10 3 79 4 15 5 42 \n0 47 1 88 2 48 3 26 4 11 5 3 \n0 58 1 78 2 49 3 48 4 51 5 5 \n0 31 1 20 2 20 3 8 4 1 5 81 \n0 87 1 17 2 75 3 34 4 7 5 93 \n0 100 1 43 2 65 3 15 4 9 5 99 \n0 74 1 45 2 74 3 67 4 86 5 72 \n0 9 1 50 2 76 3 40 4 46 5 59 \n0 26 1 40 2 95 3 59 4 74 5 87 \n0 76 1 34 2 41 3 83 4 59 5 61 \n0 93 1 90 2 79 3 77 4 36 5 58 \n0 55 1 32 2 67 3 71 4 67 5 14 \n0 24 1 89 2 40 3 43 4 91 5 16 \n0 56 1 56 2 31 3 2 4 11 5 58 \n0 91 1 85 2 80 3 22 4 100 5 94 \n0 25 1 52 2 30 3 12 4 63 5 94 \n0 63 1 71 2 56 3 11 4 63 5 24 \n0 86 1 42 2 24 3 46 4 31 5 79 \n0 64 1 58 2 32 3 77 4 36 5 43 \n0 52 1 92 2 69 3 46 4 58 5 79 \n0 13 1 81 2 76 3 52 4 34 5 28 \n0 3 1 67 2 13 3 60 4 65 5 40 \n0 68 1 40 2 46 3 11 4 98 5 27 \n0 20 1 38 2 1 3 67 4 48 5 22 \n0 45 1 66 2 69 3 31 4 43 5 50 \n0 90 1 29 2 99 3 14 4 15 5 95 \n0 75 1 25 2 16 3 33 4 70 5 77 \n0 24 1 34 2 34 3 76 4 86 5 2 \n0 20 1 73 2 84 3 91 4 20 5 93 \n0 13 1 90 2 11 3 90 4 28 5 83 \n0 84 1 55 2 36 3 72 4 93 5 39 \n0 60 1 49 2 99 3 66 4 34 5 75 \n0 31 1 29 2 93 3 98 4 42 5 85 \n0 66 1 76 2 24 3 94 4 92 5 15 \n0 59 1 51 2 33 3 38 4 62 5 86 \n0 1 1 60 2 21 3 27 4 42 5 13 \n0 5 1 7 2 30 3 99 4 48 5 92 \n0 59 1 3 2 24 3 89 4 35 5 42 \n0 74 1 2 2 53 3 14 4 80 5 45 \n0 41 1 92 2 92 3 84 4 1 5 51 \n0 98 1 59 2 36 3 35 4 58 5 8 \n0 75 1 100 2 48 3 37 4 55 5 44 \n0 29 1 62 2 96 3 11 4 5 5 29 \n0 87 1 3 2 5 3 47 4 62 5 46 \n0 34 1 76 2 18 3 38 4 42 5 27 \n0 93 1 22 2 13 3 7 4 74 5 68 \n" }, { "path": "examples/user_fssp_gls/TrainingData/28.txt", "content": "50 20\n0 58 1 64 2 2 3 49 4 100 5 54 6 89 7 55 8 17 9 50 10 58 11 86 12 79 13 70 14 87 15 15 16 64 17 18 18 53 19 97 \n0 27 1 45 2 80 3 18 4 27 5 59 6 85 7 31 8 72 9 25 10 65 11 8 12 33 13 52 14 10 15 35 16 27 17 100 18 44 19 51 \n0 34 1 31 2 29 3 84 4 36 5 20 6 86 7 80 8 19 9 9 10 84 11 58 12 98 13 74 14 52 15 44 16 24 17 39 18 97 19 87 \n0 85 1 26 2 77 3 66 4 21 5 17 6 81 7 52 8 22 9 12 10 60 11 39 12 55 13 1 14 98 15 39 16 90 17 58 18 5 19 53 \n0 5 1 54 2 13 3 99 4 80 5 42 6 81 7 81 8 47 9 8 10 36 11 19 12 93 13 55 14 66 15 100 16 75 17 54 18 35 19 68 \n0 10 1 30 2 49 3 31 4 53 5 39 6 53 7 6 8 14 9 8 10 82 11 15 12 69 13 63 14 20 15 40 16 42 17 36 18 49 19 70 \n0 54 1 46 2 34 3 8 4 24 5 80 6 63 7 91 8 32 9 65 10 25 11 23 12 67 13 77 14 71 15 71 16 27 17 79 18 10 19 28 \n0 15 1 77 2 78 3 88 4 91 5 87 6 20 7 33 8 86 9 49 10 3 11 79 12 64 13 48 14 5 15 86 16 3 17 93 18 4 19 9 \n0 43 1 6 2 26 3 49 4 14 5 1 6 15 7 24 8 96 9 81 10 51 11 30 12 40 13 15 14 29 15 29 16 41 17 54 18 42 19 72 \n0 7 1 49 2 22 3 91 4 18 5 13 6 43 7 34 8 61 9 72 10 72 11 46 12 34 13 35 14 15 15 28 16 4 17 1 18 59 19 33 \n0 52 1 96 2 12 3 38 4 32 5 12 6 89 7 37 8 60 9 21 10 41 11 51 12 63 13 85 14 73 15 15 16 90 17 27 18 39 19 57 \n0 57 1 90 2 54 3 72 4 56 5 17 6 93 7 84 8 80 9 92 10 68 11 68 12 86 13 20 14 62 15 54 16 99 17 44 18 53 19 85 \n0 54 1 16 2 36 3 6 4 86 5 98 6 45 7 42 8 63 9 22 10 4 11 72 12 65 13 94 14 38 15 25 16 58 17 92 18 38 19 15 \n0 73 1 41 2 41 3 78 4 23 5 48 6 12 7 57 8 41 9 100 10 32 11 19 12 59 13 90 14 87 15 30 16 3 17 53 18 40 19 75 \n0 88 1 20 2 33 3 19 4 21 5 59 6 2 7 53 8 15 9 33 10 10 11 37 12 49 13 5 14 98 15 21 16 73 17 80 18 55 19 2 \n0 27 1 79 2 94 3 66 4 30 5 67 6 17 7 98 8 84 9 84 10 1 11 3 12 36 13 88 14 9 15 76 16 18 17 64 18 36 19 18 \n0 4 1 3 2 41 3 69 4 20 5 15 6 78 7 13 8 44 9 90 10 74 11 17 12 9 13 74 14 17 15 34 16 78 17 54 18 99 19 68 \n0 95 1 35 2 6 3 6 4 33 5 71 6 19 7 96 8 31 9 19 10 38 11 74 12 45 13 76 14 68 15 68 16 56 17 16 18 95 19 44 \n0 80 1 86 2 26 3 92 4 42 5 32 6 61 7 93 8 31 9 56 10 65 11 48 12 3 13 39 14 80 15 41 16 51 17 48 18 36 19 39 \n0 22 1 89 2 85 3 45 4 43 5 75 6 82 7 51 8 59 9 31 10 17 11 36 12 18 13 48 14 33 15 51 16 88 17 3 18 48 19 85 \n0 45 1 70 2 55 3 22 4 90 5 55 6 85 7 37 8 92 9 65 10 2 11 70 12 82 13 12 14 52 15 17 16 62 17 13 18 78 19 70 \n0 67 1 49 2 49 3 76 4 62 5 5 6 56 7 68 8 29 9 88 10 45 11 4 12 70 13 79 14 88 15 71 16 17 17 24 18 12 19 51 \n0 90 1 57 2 35 3 97 4 88 5 62 6 60 7 93 8 3 9 27 10 98 11 13 12 62 13 1 14 13 15 97 16 63 17 30 18 37 19 95 \n0 29 1 86 2 11 3 79 4 38 5 20 6 89 7 30 8 22 9 84 10 27 11 14 12 50 13 46 14 35 15 72 16 90 17 15 18 24 19 80 \n0 21 1 68 2 14 3 40 4 5 5 27 6 26 7 86 8 61 9 78 10 80 11 12 12 58 13 68 14 35 15 10 16 93 17 35 18 90 19 90 \n0 60 1 95 2 19 3 97 4 66 5 92 6 2 7 43 8 87 9 94 10 41 11 11 12 54 13 17 14 15 15 83 16 63 17 68 18 51 19 91 \n0 53 1 93 2 18 3 74 4 90 5 59 6 72 7 75 8 13 9 37 10 42 11 49 12 55 13 54 14 60 15 27 16 69 17 89 18 7 19 99 \n0 67 1 8 2 36 3 93 4 60 5 54 6 11 7 81 8 90 9 94 10 7 11 75 12 33 13 90 14 33 15 80 16 99 17 60 18 29 19 88 \n0 32 1 66 2 68 3 1 4 79 5 33 6 36 7 17 8 17 9 46 10 79 11 73 12 5 13 48 14 40 15 85 16 94 17 49 18 37 19 51 \n0 34 1 21 2 97 3 26 4 36 5 47 6 45 7 53 8 97 9 61 10 4 11 11 12 50 13 46 14 65 15 17 16 37 17 39 18 26 19 20 \n0 74 1 85 2 43 3 83 4 25 5 90 6 47 7 11 8 90 9 97 10 82 11 55 12 36 13 31 14 73 15 95 16 27 17 79 18 97 19 17 \n0 64 1 95 2 18 3 54 4 76 5 2 6 89 7 100 8 84 9 1 10 63 11 58 12 91 13 61 14 76 15 16 16 37 17 65 18 19 19 35 \n0 58 1 37 2 62 3 95 4 4 5 26 6 29 7 57 8 24 9 25 10 52 11 39 12 69 13 89 14 23 15 31 16 41 17 27 18 49 19 23 \n0 44 1 85 2 70 3 34 4 59 5 90 6 41 7 42 8 73 9 33 10 93 11 40 12 36 13 21 14 78 15 27 16 83 17 17 18 99 19 82 \n0 39 1 96 2 76 3 4 4 54 5 67 6 35 7 77 8 69 9 2 10 94 11 52 12 2 13 14 14 40 15 26 16 3 17 96 18 35 19 15 \n0 32 1 74 2 42 3 61 4 33 5 99 6 62 7 71 8 84 9 92 10 20 11 4 12 77 13 3 14 97 15 67 16 63 17 31 18 14 19 66 \n0 26 1 89 2 82 3 98 4 17 5 39 6 83 7 72 8 18 9 64 10 16 11 16 12 2 13 78 14 18 15 17 16 67 17 14 18 37 19 7 \n0 20 1 52 2 88 3 2 4 35 5 61 6 13 7 41 8 18 9 81 10 79 11 22 12 30 13 7 14 75 15 18 16 14 17 37 18 65 19 72 \n0 49 1 87 2 58 3 45 4 92 5 91 6 60 7 63 8 17 9 13 10 17 11 39 12 93 13 58 14 43 15 56 16 12 17 29 18 25 19 30 \n0 80 1 59 2 17 3 23 4 34 5 7 6 80 7 4 8 52 9 6 10 21 11 40 12 77 13 44 14 12 15 35 16 84 17 43 18 36 19 57 \n0 42 1 7 2 80 3 36 4 95 5 71 6 86 7 50 8 16 9 31 10 47 11 73 12 56 13 32 14 93 15 10 16 57 17 15 18 61 19 22 \n0 13 1 88 2 28 3 70 4 59 5 91 6 10 7 43 8 27 9 31 10 50 11 87 12 13 13 24 14 6 15 32 16 93 17 99 18 57 19 49 \n0 46 1 34 2 65 3 69 4 59 5 43 6 29 7 56 8 71 9 94 10 48 11 23 12 35 13 5 14 19 15 70 16 13 17 79 18 22 19 55 \n0 16 1 6 2 70 3 96 4 65 5 37 6 56 7 18 8 85 9 81 10 65 11 42 12 70 13 84 14 28 15 21 16 27 17 79 18 46 19 65 \n0 35 1 96 2 84 3 72 4 5 5 79 6 86 7 74 8 96 9 34 10 74 11 15 12 23 13 78 14 7 15 24 16 26 17 95 18 76 19 47 \n0 59 1 26 2 66 3 98 4 75 5 31 6 97 7 100 8 72 9 63 10 62 11 5 12 19 13 57 14 45 15 38 16 13 17 27 18 63 19 28 \n0 6 1 22 2 12 3 36 4 91 5 61 6 40 7 31 8 90 9 85 10 52 11 99 12 27 13 93 14 16 15 49 16 44 17 31 18 33 19 69 \n0 20 1 4 2 25 3 62 4 22 5 41 6 23 7 18 8 15 9 85 10 93 11 40 12 32 13 37 14 22 15 33 16 11 17 23 18 38 19 4 \n0 57 1 55 2 51 3 6 4 69 5 17 6 5 7 81 8 48 9 55 10 12 11 77 12 32 13 36 14 73 15 54 16 43 17 82 18 75 19 33 \n0 8 1 93 2 38 3 71 4 96 5 17 6 86 7 11 8 4 9 71 10 39 11 89 12 68 13 71 14 67 15 47 16 47 17 26 18 98 19 46 \n" }, { "path": "examples/user_fssp_gls/TrainingData/29.txt", "content": "50 6\n0 64 1 78 2 24 3 99 4 72 5 53 \n0 2 1 88 2 85 3 32 4 55 5 79 \n0 93 1 10 2 16 3 90 4 26 5 34 \n0 38 1 41 2 52 3 28 4 81 5 99 \n0 54 1 5 2 88 3 74 4 83 5 52 \n0 97 1 37 2 74 3 39 4 84 5 39 \n0 92 1 90 2 8 3 81 4 88 5 34 \n0 68 1 25 2 88 3 51 4 21 5 71 \n0 44 1 54 2 44 3 9 4 62 5 77 \n0 79 1 60 2 6 3 1 4 80 5 53 \n0 4 1 50 2 19 3 62 4 46 5 71 \n0 100 1 50 2 16 3 29 4 94 5 31 \n0 91 1 16 2 20 3 78 4 97 5 36 \n0 18 1 63 2 71 3 64 4 76 5 96 \n0 81 1 11 2 1 3 16 4 51 5 51 \n0 14 1 40 2 49 3 62 4 46 5 33 \n0 3 1 94 2 11 3 68 4 11 5 17 \n0 71 1 32 2 3 3 21 4 12 5 85 \n0 90 1 75 2 38 3 77 4 69 5 63 \n0 86 1 44 2 5 3 99 4 65 5 53 \n0 76 1 75 2 45 3 3 4 56 5 29 \n0 70 1 81 2 33 3 71 4 54 5 7 \n0 14 1 28 2 60 3 45 4 83 5 64 \n0 19 1 74 2 79 3 97 4 25 5 31 \n0 71 1 57 2 31 3 98 4 16 5 39 \n0 14 1 17 2 83 3 32 4 21 5 100 \n0 95 1 90 2 62 3 20 4 61 5 74 \n0 54 1 2 2 25 3 33 4 72 5 92 \n0 3 1 70 2 36 3 22 4 32 5 94 \n0 64 1 77 2 92 3 85 4 11 5 77 \n0 5 1 46 2 40 3 33 4 73 5 1 \n0 18 1 18 2 66 3 23 4 35 5 22 \n0 91 1 20 2 93 3 11 4 22 5 85 \n0 88 1 91 2 56 3 47 4 26 5 4 \n0 31 1 36 2 96 3 42 4 82 5 68 \n0 26 1 83 2 65 3 50 4 7 5 18 \n0 4 1 17 2 17 3 60 4 2 5 9 \n0 54 1 62 2 39 3 54 4 25 5 56 \n0 16 1 15 2 56 3 68 4 41 5 27 \n0 97 1 81 2 39 3 99 4 73 5 60 \n0 23 1 80 2 5 3 85 4 35 5 94 \n0 20 1 80 2 51 3 45 4 59 5 10 \n0 75 1 29 2 48 3 36 4 47 5 33 \n0 77 1 66 2 63 3 88 4 54 5 85 \n0 85 1 25 2 19 3 3 4 13 5 67 \n0 41 1 96 2 41 3 56 4 82 5 82 \n0 99 1 71 2 80 3 44 4 66 5 6 \n0 66 1 70 2 36 3 33 4 79 5 76 \n0 100 1 14 2 100 3 29 4 51 5 73 \n0 1 1 50 2 46 3 97 4 70 5 83 \n" }, { "path": "examples/user_fssp_gls/TrainingData/3.txt", "content": "50 14\n0 88 1 55 2 35 3 59 4 50 5 40 6 8 7 34 8 9 9 38 10 54 11 23 12 93 13 3 \n0 21 1 30 2 83 3 52 4 16 5 63 6 42 7 88 8 70 9 77 10 46 11 78 12 51 13 3 \n0 88 1 90 2 48 3 100 4 4 5 71 6 14 7 39 8 81 9 66 10 19 11 33 12 84 13 48 \n0 2 1 64 2 22 3 60 4 71 5 42 6 71 7 67 8 11 9 49 10 69 11 20 12 59 13 30 \n0 69 1 91 2 54 3 51 4 74 5 57 6 77 7 24 8 46 9 43 10 33 11 89 12 72 13 44 \n0 36 1 46 2 99 3 83 4 2 5 12 6 22 7 97 8 53 9 50 10 10 11 5 12 90 13 56 \n0 79 1 88 2 64 3 56 4 93 5 10 6 75 7 18 8 37 9 54 10 45 11 98 12 84 13 60 \n0 18 1 34 2 88 3 95 4 12 5 44 6 92 7 76 8 13 9 39 10 91 11 57 12 59 13 21 \n0 14 1 96 2 27 3 57 4 7 5 9 6 65 7 50 8 83 9 78 10 39 11 58 12 1 13 41 \n0 88 1 65 2 54 3 42 4 68 5 97 6 39 7 19 8 32 9 2 10 23 11 10 12 28 13 66 \n0 59 1 18 2 43 3 73 4 34 5 61 6 67 7 2 8 4 9 65 10 14 11 74 12 67 13 84 \n0 10 1 56 2 40 3 16 4 24 5 34 6 5 7 5 8 40 9 36 10 76 11 32 12 97 13 35 \n0 25 1 79 2 61 3 44 4 1 5 13 6 97 7 57 8 46 9 37 10 93 11 69 12 67 13 31 \n0 77 1 25 2 43 3 6 4 49 5 91 6 87 7 56 8 62 9 60 10 39 11 34 12 23 13 7 \n0 31 1 36 2 24 3 66 4 16 5 18 6 72 7 12 8 99 9 88 10 38 11 47 12 4 13 58 \n0 33 1 32 2 18 3 43 4 92 5 99 6 36 7 15 8 53 9 38 10 74 11 19 12 32 13 70 \n0 57 1 40 2 26 3 75 4 1 5 92 6 61 7 39 8 38 9 47 10 34 11 100 12 75 13 33 \n0 18 1 63 2 33 3 52 4 9 5 39 6 92 7 69 8 2 9 16 10 24 11 39 12 21 13 48 \n0 78 1 16 2 14 3 39 4 97 5 61 6 59 7 29 8 15 9 38 10 83 11 12 12 24 13 68 \n0 3 1 12 2 64 3 53 4 17 5 47 6 63 7 17 8 72 9 75 10 46 11 8 12 2 13 56 \n0 63 1 15 2 72 3 56 4 11 5 82 6 39 7 23 8 91 9 48 10 46 11 23 12 100 13 87 \n0 73 1 87 2 69 3 65 4 94 5 44 6 99 7 20 8 43 9 96 10 41 11 15 12 39 13 8 \n0 3 1 49 2 93 3 85 4 95 5 25 6 45 7 72 8 24 9 6 10 3 11 56 12 45 13 32 \n0 80 1 84 2 67 3 50 4 53 5 41 6 20 7 60 8 65 9 1 10 90 11 56 12 6 13 53 \n0 3 1 59 2 11 3 79 4 6 5 40 6 50 7 9 8 26 9 93 10 84 11 81 12 24 13 52 \n0 57 1 83 2 44 3 72 4 42 5 89 6 90 7 12 8 15 9 73 10 93 11 69 12 56 13 38 \n0 82 1 45 2 44 3 79 4 98 5 41 6 68 7 7 8 64 9 88 10 10 11 3 12 51 13 26 \n0 79 1 17 2 24 3 25 4 67 5 55 6 91 7 98 8 46 9 18 10 20 11 22 12 17 13 76 \n0 58 1 78 2 28 3 56 4 2 5 79 6 35 7 33 8 18 9 60 10 32 11 78 12 80 13 86 \n0 69 1 40 2 81 3 18 4 78 5 33 6 84 7 33 8 49 9 25 10 42 11 29 12 20 13 61 \n0 98 1 10 2 31 3 74 4 97 5 83 6 36 7 56 8 4 9 100 10 12 11 44 12 38 13 22 \n0 92 1 52 2 93 3 99 4 96 5 75 6 68 7 39 8 48 9 63 10 87 11 85 12 71 13 42 \n0 69 1 29 2 95 3 34 4 62 5 66 6 97 7 44 8 100 9 91 10 69 11 22 12 86 13 87 \n0 44 1 57 2 80 3 30 4 7 5 40 6 11 7 41 8 50 9 93 10 40 11 27 12 42 13 67 \n0 79 1 85 2 30 3 65 4 44 5 20 6 1 7 37 8 9 9 71 10 14 11 97 12 45 13 12 \n0 17 1 62 2 62 3 73 4 73 5 93 6 8 7 62 8 39 9 31 10 68 11 12 12 46 13 73 \n0 90 1 79 2 2 3 96 4 5 5 81 6 14 7 9 8 48 9 83 10 4 11 31 12 29 13 86 \n0 7 1 74 2 86 3 19 4 55 5 44 6 82 7 55 8 85 9 86 10 92 11 65 12 71 13 78 \n0 35 1 72 2 26 3 54 4 23 5 81 6 19 7 70 8 9 9 31 10 59 11 11 12 87 13 72 \n0 36 1 10 2 40 3 65 4 14 5 9 6 39 7 72 8 19 9 38 10 61 11 25 12 96 13 47 \n0 26 1 37 2 23 3 84 4 16 5 92 6 11 7 58 8 100 9 50 10 59 11 87 12 42 13 76 \n0 20 1 57 2 17 3 35 4 93 5 36 6 24 7 26 8 58 9 9 10 25 11 2 12 54 13 55 \n0 77 1 70 2 87 3 32 4 49 5 91 6 42 7 31 8 28 9 97 10 38 11 95 12 93 13 92 \n0 63 1 46 2 69 3 2 4 86 5 48 6 34 7 17 8 96 9 14 10 34 11 97 12 37 13 7 \n0 48 1 40 2 50 3 5 4 59 5 100 6 5 7 49 8 60 9 14 10 5 11 83 12 43 13 66 \n0 65 1 84 2 4 3 43 4 44 5 42 6 90 7 65 8 70 9 9 10 53 11 30 12 46 13 26 \n0 74 1 26 2 32 3 17 4 25 5 17 6 30 7 61 8 41 9 69 10 64 11 79 12 1 13 3 \n0 20 1 92 2 14 3 59 4 28 5 8 6 44 7 91 8 83 9 80 10 20 11 52 12 20 13 5 \n0 44 1 96 2 14 3 87 4 28 5 15 6 90 7 93 8 89 9 73 10 4 11 92 12 79 13 66 \n0 73 1 43 2 36 3 97 4 48 5 46 6 12 7 33 8 67 9 11 10 84 11 31 12 45 13 58 \n" }, { "path": "examples/user_fssp_gls/TrainingData/30.txt", "content": "50 19\n0 1 1 82 2 53 3 6 4 64 5 32 6 28 7 81 8 58 9 26 10 57 11 2 12 44 13 72 14 37 15 66 16 54 17 32 18 87 \n0 29 1 86 2 67 3 42 4 21 5 98 6 44 7 21 8 83 9 33 10 74 11 18 12 47 13 13 14 8 15 26 16 51 17 90 18 41 \n0 63 1 100 2 46 3 25 4 64 5 79 6 16 7 73 8 17 9 65 10 71 11 9 12 17 13 18 14 54 15 15 16 5 17 98 18 54 \n0 32 1 86 2 60 3 63 4 74 5 72 6 48 7 50 8 82 9 26 10 8 11 75 12 80 13 37 14 70 15 31 16 92 17 99 18 86 \n0 61 1 4 2 25 3 93 4 98 5 95 6 75 7 17 8 4 9 69 10 21 11 11 12 8 13 95 14 7 15 78 16 51 17 67 18 60 \n0 14 1 42 2 59 3 76 4 25 5 5 6 71 7 16 8 45 9 77 10 67 11 13 12 62 13 86 14 27 15 37 16 90 17 2 18 61 \n0 85 1 94 2 35 3 94 4 96 5 95 6 56 7 77 8 61 9 77 10 46 11 9 12 21 13 88 14 16 15 90 16 21 17 56 18 67 \n0 41 1 68 2 15 3 80 4 84 5 33 6 46 7 42 8 3 9 80 10 32 11 30 12 47 13 35 14 96 15 98 16 56 17 83 18 58 \n0 26 1 8 2 40 3 97 4 37 5 53 6 9 7 59 8 30 9 79 10 52 11 52 12 23 13 82 14 19 15 95 16 64 17 44 18 27 \n0 82 1 68 2 18 3 11 4 70 5 2 6 82 7 33 8 52 9 27 10 54 11 82 12 80 13 20 14 46 15 5 16 57 17 21 18 10 \n0 45 1 33 2 77 3 53 4 1 5 7 6 22 7 68 8 60 9 31 10 83 11 4 12 23 13 89 14 94 15 6 16 53 17 100 18 35 \n0 43 1 75 2 90 3 50 4 46 5 66 6 38 7 79 8 54 9 58 10 33 11 30 12 22 13 76 14 65 15 43 16 87 17 98 18 16 \n0 3 1 39 2 87 3 3 4 91 5 16 6 70 7 80 8 56 9 73 10 82 11 69 12 55 13 21 14 1 15 27 16 3 17 58 18 48 \n0 81 1 31 2 65 3 9 4 30 5 15 6 82 7 26 8 88 9 85 10 42 11 75 12 35 13 78 14 79 15 17 16 77 17 95 18 89 \n0 7 1 19 2 40 3 39 4 82 5 72 6 60 7 15 8 40 9 88 10 66 11 93 12 29 13 40 14 33 15 96 16 37 17 31 18 93 \n0 19 1 15 2 74 3 9 4 54 5 1 6 91 7 45 8 15 9 99 10 27 11 41 12 96 13 59 14 57 15 88 16 19 17 91 18 42 \n0 60 1 30 2 14 3 90 4 74 5 32 6 93 7 42 8 74 9 17 10 25 11 92 12 38 13 20 14 31 15 37 16 88 17 35 18 14 \n0 67 1 16 2 89 3 8 4 98 5 65 6 26 7 72 8 92 9 58 10 21 11 21 12 40 13 33 14 79 15 77 16 19 17 51 18 4 \n0 59 1 25 2 35 3 57 4 80 5 10 6 11 7 73 8 64 9 74 10 7 11 35 12 84 13 91 14 96 15 11 16 87 17 94 18 63 \n0 20 1 17 2 81 3 53 4 57 5 82 6 58 7 44 8 93 9 45 10 83 11 97 12 58 13 88 14 37 15 92 16 7 17 21 18 59 \n0 26 1 29 2 60 3 8 4 46 5 27 6 29 7 65 8 16 9 80 10 74 11 21 12 73 13 76 14 60 15 61 16 53 17 6 18 79 \n0 77 1 33 2 75 3 9 4 51 5 50 6 93 7 79 8 17 9 17 10 36 11 50 12 46 13 83 14 14 15 69 16 46 17 71 18 80 \n0 96 1 24 2 84 3 18 4 53 5 32 6 37 7 96 8 58 9 65 10 64 11 13 12 23 13 15 14 52 15 78 16 47 17 84 18 86 \n0 96 1 80 2 58 3 7 4 83 5 71 6 18 7 19 8 53 9 78 10 64 11 37 12 1 13 5 14 26 15 16 16 27 17 18 18 41 \n0 22 1 32 2 77 3 62 4 86 5 63 6 22 7 72 8 50 9 65 10 76 11 4 12 47 13 45 14 37 15 71 16 87 17 41 18 28 \n0 84 1 79 2 61 3 55 4 93 5 58 6 58 7 50 8 24 9 10 10 98 11 44 12 88 13 70 14 43 15 85 16 37 17 77 18 31 \n0 73 1 27 2 22 3 38 4 77 5 28 6 45 7 17 8 79 9 9 10 85 11 64 12 77 13 54 14 55 15 39 16 62 17 35 18 74 \n0 17 1 86 2 84 3 47 4 9 5 76 6 35 7 72 8 87 9 20 10 28 11 95 12 82 13 98 14 76 15 30 16 29 17 31 18 84 \n0 7 1 70 2 97 3 4 4 46 5 74 6 24 7 100 8 85 9 8 10 46 11 18 12 50 13 66 14 13 15 12 16 14 17 18 18 14 \n0 1 1 2 2 8 3 45 4 18 5 11 6 82 7 65 8 13 9 43 10 22 11 55 12 51 13 66 14 71 15 29 16 81 17 74 18 12 \n0 95 1 12 2 21 3 86 4 86 5 55 6 97 7 66 8 81 9 58 10 46 11 75 12 69 13 47 14 84 15 28 16 95 17 72 18 82 \n0 16 1 83 2 99 3 34 4 4 5 32 6 67 7 28 8 76 9 35 10 27 11 50 12 76 13 22 14 91 15 86 16 51 17 74 18 51 \n0 43 1 44 2 14 3 70 4 78 5 64 6 50 7 26 8 36 9 80 10 93 11 70 12 62 13 10 14 85 15 89 16 50 17 67 18 80 \n0 74 1 95 2 58 3 21 4 80 5 43 6 78 7 59 8 73 9 53 10 65 11 16 12 66 13 4 14 51 15 21 16 64 17 41 18 36 \n0 72 1 77 2 51 3 41 4 58 5 37 6 23 7 52 8 49 9 75 10 92 11 10 12 12 13 3 14 77 15 60 16 93 17 59 18 62 \n0 3 1 8 2 41 3 43 4 92 5 94 6 91 7 98 8 40 9 78 10 75 11 59 12 62 13 20 14 62 15 10 16 75 17 61 18 4 \n0 54 1 31 2 97 3 25 4 55 5 52 6 16 7 68 8 24 9 61 10 61 11 1 12 42 13 96 14 52 15 39 16 90 17 92 18 2 \n0 66 1 98 2 12 3 29 4 99 5 9 6 4 7 75 8 62 9 92 10 56 11 4 12 39 13 96 14 65 15 96 16 32 17 96 18 16 \n0 49 1 33 2 66 3 26 4 71 5 15 6 27 7 59 8 75 9 94 10 97 11 17 12 56 13 72 14 67 15 15 16 88 17 73 18 94 \n0 65 1 44 2 60 3 13 4 80 5 5 6 10 7 91 8 85 9 15 10 45 11 26 12 85 13 19 14 98 15 58 16 68 17 17 18 81 \n0 21 1 4 2 50 3 62 4 23 5 97 6 81 7 77 8 87 9 5 10 83 11 84 12 25 13 85 14 18 15 3 16 27 17 79 18 50 \n0 10 1 81 2 73 3 100 4 10 5 91 6 23 7 26 8 9 9 78 10 5 11 89 12 18 13 43 14 7 15 62 16 47 17 32 18 84 \n0 5 1 13 2 13 3 24 4 8 5 97 6 33 7 60 8 17 9 11 10 52 11 74 12 88 13 87 14 37 15 80 16 59 17 86 18 91 \n0 87 1 36 2 88 3 32 4 42 5 43 6 80 7 58 8 97 9 34 10 97 11 24 12 77 13 16 14 53 15 4 16 80 17 27 18 40 \n0 33 1 87 2 4 3 3 4 50 5 13 6 26 7 9 8 96 9 76 10 92 11 82 12 89 13 81 14 76 15 19 16 65 17 43 18 56 \n0 8 1 17 2 67 3 96 4 18 5 18 6 75 7 68 8 80 9 95 10 73 11 8 12 26 13 33 14 14 15 26 16 54 17 1 18 44 \n0 17 1 93 2 78 3 14 4 84 5 86 6 71 7 45 8 95 9 56 10 3 11 87 12 27 13 5 14 56 15 30 16 27 17 11 18 75 \n0 68 1 41 2 86 3 48 4 99 5 44 6 78 7 17 8 91 9 49 10 40 11 51 12 13 13 48 14 34 15 1 16 94 17 58 18 84 \n0 67 1 9 2 91 3 80 4 32 5 57 6 69 7 47 8 65 9 11 10 59 11 17 12 29 13 11 14 8 15 2 16 81 17 23 18 19 \n0 48 1 51 2 16 3 86 4 50 5 40 6 90 7 90 8 39 9 38 10 94 11 68 12 52 13 51 14 55 15 89 16 62 17 33 18 11 \n" }, { "path": "examples/user_fssp_gls/TrainingData/31.txt", "content": "50 8\n0 72 1 20 2 93 3 1 4 56 5 43 6 13 7 22 \n0 71 1 76 2 50 3 23 4 73 5 16 6 93 7 62 \n0 4 1 65 2 37 3 8 4 9 5 43 6 44 7 13 \n0 46 1 69 2 32 3 71 4 56 5 48 6 36 7 70 \n0 91 1 7 2 97 3 17 4 81 5 89 6 33 7 2 \n0 43 1 12 2 63 3 34 4 72 5 70 6 4 7 81 \n0 80 1 44 2 21 3 23 4 66 5 19 6 58 7 97 \n0 80 1 58 2 67 3 4 4 82 5 37 6 24 7 73 \n0 20 1 84 2 55 3 56 4 23 5 100 6 64 7 89 \n0 13 1 31 2 41 3 91 4 46 5 6 6 94 7 44 \n0 27 1 80 2 47 3 18 4 44 5 86 6 69 7 31 \n0 30 1 15 2 64 3 28 4 96 5 100 6 74 7 54 \n0 4 1 81 2 82 3 21 4 41 5 52 6 16 7 46 \n0 73 1 21 2 32 3 70 4 67 5 93 6 61 7 37 \n0 45 1 59 2 32 3 21 4 14 5 37 6 16 7 68 \n0 81 1 42 2 29 3 65 4 32 5 80 6 96 7 1 \n0 88 1 57 2 66 3 90 4 91 5 85 6 37 7 73 \n0 100 1 15 2 87 3 65 4 42 5 81 6 96 7 4 \n0 98 1 72 2 27 3 31 4 16 5 58 6 47 7 78 \n0 57 1 37 2 34 3 93 4 44 5 1 6 13 7 87 \n0 79 1 8 2 37 3 30 4 48 5 33 6 88 7 74 \n0 58 1 83 2 68 3 88 4 81 5 1 6 100 7 24 \n0 93 1 46 2 53 3 9 4 20 5 58 6 84 7 57 \n0 99 1 60 2 75 3 93 4 46 5 56 6 92 7 4 \n0 29 1 62 2 89 3 59 4 37 5 73 6 85 7 52 \n0 52 1 70 2 43 3 34 4 33 5 53 6 81 7 54 \n0 22 1 30 2 26 3 83 4 92 5 8 6 67 7 78 \n0 3 1 96 2 35 3 15 4 46 5 90 6 45 7 51 \n0 71 1 54 2 29 3 77 4 22 5 73 6 62 7 57 \n0 86 1 9 2 74 3 68 4 31 5 28 6 8 7 5 \n0 83 1 56 2 37 3 56 4 15 5 13 6 54 7 20 \n0 21 1 67 2 75 3 59 4 11 5 72 6 68 7 38 \n0 66 1 26 2 26 3 39 4 52 5 68 6 65 7 4 \n0 56 1 84 2 32 3 83 4 81 5 26 6 5 7 60 \n0 81 1 28 2 60 3 85 4 45 5 13 6 43 7 5 \n0 100 1 39 2 70 3 69 4 36 5 58 6 74 7 8 \n0 23 1 100 2 4 3 63 4 28 5 71 6 56 7 40 \n0 59 1 21 2 88 3 18 4 13 5 64 6 83 7 59 \n0 34 1 60 2 76 3 66 4 51 5 78 6 70 7 33 \n0 71 1 100 2 58 3 51 4 85 5 9 6 88 7 1 \n0 63 1 87 2 28 3 10 4 44 5 58 6 25 7 93 \n0 82 1 67 2 70 3 65 4 74 5 92 6 16 7 86 \n0 13 1 97 2 93 3 74 4 38 5 18 6 14 7 60 \n0 91 1 67 2 53 3 63 4 34 5 66 6 59 7 5 \n0 31 1 15 2 41 3 5 4 92 5 56 6 74 7 86 \n0 63 1 7 2 2 3 79 4 70 5 38 6 26 7 73 \n0 35 1 38 2 33 3 67 4 78 5 90 6 96 7 73 \n0 4 1 88 2 42 3 57 4 83 5 10 6 6 7 51 \n0 27 1 22 2 97 3 83 4 77 5 40 6 36 7 25 \n0 36 1 39 2 22 3 36 4 39 5 56 6 48 7 70 \n" }, { "path": "examples/user_fssp_gls/TrainingData/32.txt", "content": "50 8\n0 66 1 62 2 38 3 93 4 100 5 37 6 43 7 77 \n0 72 1 86 2 88 3 93 4 83 5 5 6 5 7 64 \n0 65 1 44 2 75 3 53 4 86 5 80 6 100 7 61 \n0 47 1 39 2 91 3 55 4 44 5 62 6 93 7 73 \n0 73 1 92 2 50 3 47 4 72 5 48 6 47 7 11 \n0 78 1 52 2 52 3 23 4 91 5 37 6 76 7 29 \n0 82 1 25 2 64 3 86 4 50 5 85 6 53 7 43 \n0 73 1 70 2 65 3 36 4 77 5 93 6 22 7 89 \n0 87 1 95 2 77 3 20 4 85 5 70 6 4 7 65 \n0 77 1 56 2 68 3 2 4 73 5 43 6 84 7 4 \n0 82 1 12 2 59 3 24 4 55 5 72 6 32 7 50 \n0 22 1 84 2 71 3 37 4 36 5 37 6 42 7 81 \n0 68 1 41 2 26 3 51 4 2 5 52 6 40 7 4 \n0 100 1 2 2 39 3 39 4 47 5 38 6 75 7 93 \n0 57 1 7 2 38 3 85 4 13 5 13 6 12 7 56 \n0 64 1 11 2 34 3 14 4 25 5 16 6 34 7 50 \n0 99 1 82 2 80 3 67 4 45 5 100 6 19 7 54 \n0 73 1 54 2 4 3 45 4 39 5 21 6 40 7 33 \n0 68 1 81 2 39 3 83 4 63 5 18 6 89 7 50 \n0 31 1 41 2 53 3 33 4 15 5 28 6 64 7 94 \n0 31 1 30 2 79 3 1 4 68 5 16 6 70 7 64 \n0 6 1 98 2 9 3 80 4 53 5 21 6 44 7 21 \n0 40 1 81 2 41 3 100 4 71 5 81 6 85 7 28 \n0 63 1 94 2 86 3 1 4 74 5 88 6 99 7 31 \n0 13 1 92 2 99 3 68 4 26 5 83 6 77 7 44 \n0 10 1 34 2 83 3 35 4 8 5 42 6 13 7 39 \n0 3 1 91 2 60 3 33 4 86 5 11 6 99 7 84 \n0 88 1 50 2 67 3 12 4 59 5 46 6 20 7 1 \n0 98 1 28 2 56 3 96 4 2 5 56 6 66 7 71 \n0 92 1 36 2 95 3 92 4 51 5 87 6 99 7 36 \n0 3 1 6 2 14 3 65 4 21 5 33 6 34 7 49 \n0 19 1 19 2 65 3 24 4 46 5 80 6 87 7 94 \n0 90 1 11 2 36 3 45 4 10 5 40 6 15 7 24 \n0 37 1 85 2 61 3 72 4 71 5 37 6 85 7 55 \n0 50 1 47 2 70 3 66 4 34 5 61 6 72 7 42 \n0 24 1 18 2 1 3 39 4 74 5 52 6 40 7 63 \n0 4 1 49 2 6 3 25 4 44 5 94 6 15 7 86 \n0 19 1 38 2 21 3 63 4 3 5 73 6 74 7 80 \n0 100 1 1 2 80 3 46 4 72 5 25 6 43 7 84 \n0 14 1 76 2 72 3 49 4 91 5 52 6 86 7 83 \n0 80 1 44 2 25 3 9 4 46 5 12 6 83 7 8 \n0 1 1 63 2 16 3 14 4 62 5 96 6 17 7 19 \n0 9 1 89 2 19 3 16 4 38 5 87 6 60 7 2 \n0 90 1 96 2 38 3 27 4 97 5 23 6 67 7 63 \n0 53 1 59 2 80 3 2 4 58 5 64 6 23 7 24 \n0 62 1 7 2 89 3 62 4 69 5 78 6 65 7 34 \n0 44 1 55 2 82 3 73 4 15 5 31 6 49 7 16 \n0 36 1 38 2 24 3 22 4 42 5 59 6 64 7 6 \n0 84 1 86 2 28 3 59 4 98 5 35 6 60 7 90 \n0 62 1 53 2 47 3 40 4 59 5 100 6 30 7 5 \n" }, { "path": "examples/user_fssp_gls/TrainingData/33.txt", "content": "50 8\n0 16 1 88 2 52 3 25 4 5 5 55 6 65 7 36 \n0 74 1 36 2 49 3 7 4 31 5 65 6 70 7 33 \n0 39 1 73 2 47 3 92 4 42 5 31 6 72 7 40 \n0 100 1 28 2 83 3 58 4 28 5 50 6 83 7 78 \n0 16 1 15 2 67 3 19 4 86 5 73 6 16 7 59 \n0 84 1 28 2 4 3 69 4 16 5 78 6 79 7 60 \n0 84 1 63 2 15 3 11 4 7 5 64 6 78 7 56 \n0 58 1 7 2 20 3 57 4 6 5 67 6 100 7 85 \n0 37 1 99 2 1 3 24 4 95 5 98 6 63 7 72 \n0 21 1 79 2 45 3 42 4 3 5 24 6 47 7 38 \n0 71 1 41 2 46 3 14 4 41 5 36 6 54 7 64 \n0 19 1 14 2 69 3 37 4 14 5 86 6 2 7 65 \n0 3 1 93 2 55 3 80 4 79 5 1 6 87 7 7 \n0 13 1 81 2 52 3 89 4 78 5 55 6 63 7 94 \n0 25 1 82 2 96 3 93 4 66 5 13 6 90 7 1 \n0 98 1 32 2 88 3 66 4 6 5 47 6 38 7 96 \n0 74 1 12 2 15 3 88 4 13 5 21 6 8 7 100 \n0 10 1 65 2 24 3 70 4 34 5 31 6 8 7 27 \n0 11 1 6 2 25 3 35 4 31 5 18 6 36 7 86 \n0 27 1 7 2 19 3 89 4 65 5 69 6 12 7 2 \n0 92 1 89 2 26 3 66 4 4 5 96 6 8 7 78 \n0 71 1 5 2 64 3 36 4 20 5 70 6 9 7 94 \n0 98 1 57 2 58 3 79 4 31 5 87 6 91 7 22 \n0 42 1 82 2 23 3 45 4 68 5 88 6 24 7 55 \n0 55 1 95 2 49 3 90 4 96 5 39 6 54 7 50 \n0 41 1 68 2 82 3 35 4 84 5 93 6 17 7 57 \n0 31 1 56 2 64 3 44 4 80 5 40 6 54 7 51 \n0 18 1 46 2 12 3 96 4 60 5 53 6 42 7 26 \n0 81 1 24 2 23 3 15 4 46 5 68 6 86 7 39 \n0 51 1 50 2 69 3 94 4 50 5 53 6 52 7 82 \n0 66 1 21 2 2 3 54 4 65 5 98 6 90 7 31 \n0 43 1 16 2 16 3 79 4 90 5 38 6 81 7 41 \n0 3 1 65 2 76 3 14 4 35 5 10 6 39 7 9 \n0 17 1 25 2 68 3 17 4 64 5 90 6 55 7 49 \n0 84 1 79 2 74 3 75 4 71 5 81 6 6 7 78 \n0 63 1 97 2 83 3 97 4 27 5 94 6 29 7 2 \n0 81 1 52 2 89 3 96 4 14 5 4 6 52 7 78 \n0 22 1 46 2 27 3 73 4 90 5 44 6 13 7 5 \n0 42 1 70 2 88 3 95 4 92 5 50 6 94 7 5 \n0 86 1 97 2 96 3 43 4 68 5 35 6 50 7 46 \n0 78 1 43 2 56 3 6 4 91 5 6 6 3 7 16 \n0 29 1 61 2 5 3 12 4 89 5 100 6 13 7 100 \n0 13 1 46 2 85 3 76 4 29 5 81 6 77 7 40 \n0 24 1 60 2 27 3 78 4 29 5 74 6 83 7 92 \n0 70 1 35 2 99 3 61 4 57 5 14 6 34 7 100 \n0 80 1 48 2 14 3 19 4 26 5 28 6 27 7 57 \n0 81 1 22 2 51 3 4 4 77 5 24 6 22 7 18 \n0 84 1 45 2 15 3 49 4 59 5 94 6 54 7 24 \n0 36 1 63 2 73 3 15 4 41 5 10 6 66 7 44 \n0 24 1 14 2 50 3 5 4 35 5 76 6 47 7 26 \n" }, { "path": "examples/user_fssp_gls/TrainingData/34.txt", "content": "50 6\n0 83 1 19 2 3 3 52 4 36 5 64 \n0 13 1 26 2 32 3 40 4 79 5 80 \n0 23 1 6 2 58 3 88 4 85 5 79 \n0 60 1 49 2 19 3 72 4 64 5 1 \n0 72 1 23 2 42 3 44 4 52 5 20 \n0 61 1 70 2 71 3 22 4 75 5 13 \n0 23 1 62 2 24 3 35 4 78 5 29 \n0 30 1 43 2 68 3 17 4 50 5 37 \n0 43 1 29 2 36 3 80 4 14 5 98 \n0 55 1 14 2 21 3 46 4 39 5 44 \n0 19 1 49 2 92 3 69 4 85 5 65 \n0 50 1 16 2 19 3 69 4 30 5 99 \n0 26 1 84 2 41 3 34 4 17 5 30 \n0 75 1 28 2 79 3 87 4 62 5 46 \n0 43 1 60 2 36 3 45 4 48 5 18 \n0 92 1 27 2 77 3 23 4 79 5 50 \n0 54 1 23 2 60 3 34 4 12 5 23 \n0 68 1 73 2 8 3 70 4 31 5 5 \n0 73 1 61 2 4 3 51 4 75 5 57 \n0 89 1 25 2 37 3 24 4 77 5 7 \n0 71 1 75 2 84 3 92 4 31 5 5 \n0 37 1 2 2 56 3 89 4 59 5 12 \n0 86 1 57 2 24 3 26 4 65 5 78 \n0 96 1 5 2 29 3 79 4 62 5 19 \n0 97 1 14 2 2 3 29 4 55 5 34 \n0 89 1 11 2 84 3 81 4 74 5 34 \n0 27 1 65 2 33 3 89 4 9 5 94 \n0 43 1 27 2 91 3 77 4 68 5 6 \n0 91 1 86 2 71 3 73 4 86 5 49 \n0 34 1 45 2 94 3 59 4 32 5 23 \n0 85 1 5 2 56 3 54 4 98 5 63 \n0 14 1 31 2 5 3 18 4 44 5 87 \n0 85 1 40 2 7 3 10 4 65 5 30 \n0 94 1 69 2 37 3 14 4 3 5 76 \n0 29 1 45 2 32 3 72 4 41 5 70 \n0 33 1 36 2 33 3 42 4 45 5 44 \n0 24 1 96 2 38 3 88 4 22 5 86 \n0 54 1 93 2 59 3 47 4 14 5 7 \n0 94 1 91 2 21 3 40 4 21 5 86 \n0 61 1 88 2 31 3 44 4 50 5 84 \n0 47 1 68 2 26 3 29 4 33 5 41 \n0 33 1 97 2 7 3 2 4 90 5 87 \n0 72 1 31 2 69 3 16 4 94 5 87 \n0 2 1 3 2 29 3 9 4 12 5 98 \n0 85 1 89 2 79 3 44 4 54 5 51 \n0 34 1 34 2 68 3 4 4 28 5 76 \n0 25 1 27 2 88 3 21 4 91 5 64 \n0 14 1 61 2 45 3 46 4 89 5 77 \n0 66 1 39 2 82 3 74 4 72 5 46 \n0 26 1 11 2 38 3 22 4 7 5 35 \n" }, { "path": "examples/user_fssp_gls/TrainingData/35.txt", "content": "50 16\n0 50 1 53 2 66 3 67 4 28 5 90 6 31 7 58 8 36 9 79 10 26 11 12 12 51 13 7 14 28 15 8 \n0 90 1 86 2 39 3 69 4 98 5 93 6 86 7 34 8 67 9 25 10 86 11 98 12 54 13 83 14 100 15 72 \n0 27 1 6 2 83 3 54 4 13 5 73 6 13 7 24 8 60 9 40 10 43 11 86 12 80 13 82 14 72 15 99 \n0 35 1 35 2 48 3 72 4 10 5 32 6 8 7 88 8 84 9 7 10 84 11 63 12 73 13 74 14 60 15 34 \n0 76 1 2 2 55 3 75 4 76 5 95 6 51 7 97 8 78 9 34 10 49 11 35 12 75 13 3 14 63 15 27 \n0 51 1 49 2 45 3 39 4 56 5 16 6 65 7 59 8 65 9 60 10 57 11 78 12 14 13 44 14 100 15 2 \n0 55 1 49 2 91 3 49 4 39 5 52 6 13 7 17 8 61 9 25 10 28 11 49 12 84 13 90 14 17 15 26 \n0 52 1 26 2 18 3 81 4 34 5 49 6 95 7 17 8 2 9 52 10 70 11 63 12 88 13 80 14 25 15 90 \n0 50 1 90 2 100 3 58 4 31 5 31 6 23 7 42 8 63 9 27 10 49 11 99 12 51 13 18 14 74 15 31 \n0 51 1 38 2 36 3 52 4 43 5 46 6 21 7 16 8 61 9 46 10 29 11 29 12 61 13 73 14 8 15 41 \n0 81 1 37 2 81 3 73 4 78 5 99 6 40 7 40 8 94 9 50 10 80 11 37 12 54 13 28 14 16 15 51 \n0 90 1 20 2 75 3 70 4 39 5 20 6 89 7 38 8 12 9 1 10 32 11 58 12 52 13 32 14 63 15 66 \n0 37 1 85 2 83 3 77 4 18 5 46 6 73 7 96 8 80 9 41 10 18 11 48 12 88 13 43 14 21 15 99 \n0 4 1 95 2 96 3 80 4 45 5 20 6 85 7 72 8 50 9 99 10 34 11 11 12 96 13 18 14 37 15 47 \n0 53 1 66 2 64 3 95 4 73 5 85 6 84 7 33 8 17 9 83 10 36 11 82 12 47 13 32 14 17 15 3 \n0 47 1 1 2 63 3 27 4 80 5 51 6 21 7 30 8 99 9 66 10 88 11 38 12 48 13 90 14 32 15 4 \n0 83 1 33 2 40 3 57 4 67 5 17 6 25 7 46 8 47 9 65 10 26 11 68 12 88 13 3 14 31 15 16 \n0 26 1 14 2 100 3 78 4 17 5 21 6 9 7 88 8 38 9 47 10 44 11 49 12 81 13 21 14 66 15 20 \n0 61 1 55 2 11 3 52 4 60 5 20 6 58 7 69 8 79 9 23 10 47 11 71 12 89 13 54 14 29 15 94 \n0 49 1 44 2 15 3 5 4 39 5 90 6 42 7 77 8 53 9 78 10 67 11 43 12 80 13 92 14 21 15 56 \n0 81 1 81 2 99 3 83 4 68 5 77 6 61 7 79 8 53 9 18 10 84 11 62 12 46 13 57 14 43 15 67 \n0 23 1 48 2 21 3 74 4 7 5 1 6 26 7 14 8 62 9 88 10 16 11 15 12 36 13 96 14 82 15 39 \n0 25 1 72 2 27 3 35 4 72 5 64 6 73 7 78 8 45 9 79 10 95 11 25 12 16 13 75 14 72 15 53 \n0 92 1 13 2 21 3 57 4 100 5 39 6 90 7 48 8 46 9 26 10 15 11 29 12 56 13 64 14 34 15 46 \n0 27 1 37 2 66 3 21 4 47 5 83 6 70 7 62 8 99 9 1 10 53 11 64 12 39 13 30 14 13 15 42 \n0 44 1 25 2 47 3 66 4 74 5 35 6 88 7 39 8 89 9 41 10 65 11 74 12 89 13 28 14 97 15 68 \n0 94 1 40 2 97 3 37 4 47 5 44 6 89 7 71 8 96 9 6 10 11 11 88 12 26 13 3 14 38 15 28 \n0 93 1 32 2 84 3 79 4 68 5 4 6 16 7 18 8 76 9 37 10 7 11 2 12 94 13 32 14 79 15 69 \n0 8 1 37 2 70 3 76 4 26 5 71 6 72 7 94 8 79 9 30 10 82 11 5 12 13 13 26 14 15 15 13 \n0 17 1 21 2 66 3 59 4 94 5 79 6 59 7 43 8 70 9 86 10 80 11 26 12 85 13 79 14 50 15 56 \n0 84 1 46 2 76 3 77 4 15 5 50 6 11 7 5 8 86 9 72 10 42 11 25 12 52 13 68 14 83 15 80 \n0 19 1 11 2 51 3 22 4 55 5 81 6 98 7 23 8 7 9 33 10 13 11 87 12 11 13 39 14 81 15 76 \n0 92 1 93 2 96 3 30 4 100 5 74 6 12 7 3 8 11 9 57 10 61 11 6 12 15 13 66 14 42 15 18 \n0 92 1 2 2 13 3 70 4 57 5 48 6 69 7 49 8 91 9 18 10 30 11 72 12 28 13 41 14 7 15 44 \n0 18 1 39 2 7 3 46 4 65 5 76 6 70 7 98 8 20 9 42 10 20 11 15 12 16 13 63 14 35 15 49 \n0 17 1 72 2 88 3 39 4 30 5 16 6 2 7 15 8 26 9 9 10 19 11 62 12 58 13 57 14 22 15 31 \n0 32 1 68 2 52 3 30 4 58 5 7 6 43 7 70 8 34 9 33 10 49 11 86 12 39 13 14 14 39 15 75 \n0 57 1 35 2 35 3 57 4 53 5 47 6 52 7 24 8 3 9 5 10 84 11 89 12 63 13 29 14 24 15 42 \n0 77 1 16 2 44 3 70 4 10 5 10 6 99 7 99 8 6 9 95 10 57 11 80 12 30 13 60 14 5 15 70 \n0 42 1 53 2 84 3 86 4 48 5 68 6 92 7 3 8 36 9 10 10 26 11 90 12 13 13 79 14 95 15 98 \n0 74 1 82 2 46 3 37 4 47 5 52 6 99 7 50 8 92 9 74 10 35 11 74 12 35 13 28 14 31 15 87 \n0 62 1 41 2 52 3 33 4 56 5 51 6 64 7 15 8 13 9 48 10 49 11 46 12 15 13 98 14 91 15 55 \n0 11 1 35 2 64 3 12 4 2 5 55 6 38 7 40 8 10 9 58 10 7 11 4 12 49 13 66 14 99 15 87 \n0 47 1 24 2 48 3 27 4 2 5 9 6 17 7 37 8 99 9 60 10 73 11 99 12 94 13 21 14 27 15 73 \n0 88 1 59 2 40 3 72 4 49 5 20 6 3 7 33 8 85 9 58 10 33 11 18 12 74 13 88 14 38 15 14 \n0 55 1 3 2 8 3 50 4 68 5 74 6 87 7 33 8 35 9 2 10 39 11 17 12 69 13 80 14 37 15 89 \n0 39 1 86 2 23 3 35 4 99 5 31 6 6 7 75 8 56 9 55 10 11 11 99 12 71 13 56 14 33 15 94 \n0 23 1 77 2 85 3 37 4 64 5 5 6 23 7 3 8 57 9 85 10 61 11 25 12 78 13 63 14 23 15 90 \n0 88 1 90 2 2 3 72 4 11 5 90 6 42 7 65 8 58 9 20 10 38 11 36 12 55 13 50 14 3 15 97 \n0 73 1 89 2 97 3 89 4 66 5 71 6 16 7 70 8 36 9 89 10 38 11 84 12 14 13 51 14 64 15 85 \n" }, { "path": "examples/user_fssp_gls/TrainingData/36.txt", "content": "50 6\n0 17 1 12 2 85 3 52 4 18 5 73 \n0 79 1 66 2 70 3 69 4 58 5 68 \n0 80 1 29 2 10 3 75 4 33 5 93 \n0 24 1 84 2 90 3 90 4 85 5 95 \n0 92 1 89 2 52 3 63 4 21 5 93 \n0 64 1 68 2 31 3 19 4 10 5 2 \n0 73 1 11 2 65 3 26 4 36 5 30 \n0 98 1 23 2 86 3 34 4 58 5 15 \n0 97 1 23 2 91 3 96 4 24 5 71 \n0 27 1 59 2 34 3 83 4 83 5 65 \n0 31 1 76 2 98 3 10 4 39 5 18 \n0 93 1 17 2 80 3 26 4 23 5 89 \n0 3 1 78 2 99 3 48 4 67 5 62 \n0 41 1 41 2 12 3 52 4 18 5 59 \n0 24 1 44 2 93 3 50 4 37 5 59 \n0 82 1 26 2 75 3 85 4 57 5 56 \n0 40 1 100 2 60 3 66 4 70 5 60 \n0 29 1 7 2 5 3 79 4 85 5 30 \n0 36 1 11 2 71 3 88 4 97 5 67 \n0 74 1 36 2 21 3 81 4 81 5 34 \n0 36 1 27 2 4 3 82 4 43 5 78 \n0 49 1 79 2 100 3 75 4 27 5 91 \n0 40 1 22 2 78 3 26 4 35 5 41 \n0 60 1 35 2 76 3 40 4 14 5 6 \n0 70 1 91 2 10 3 58 4 49 5 69 \n0 86 1 40 2 22 3 6 4 3 5 42 \n0 23 1 80 2 5 3 100 4 22 5 96 \n0 5 1 96 2 82 3 35 4 36 5 44 \n0 71 1 4 2 56 3 17 4 18 5 90 \n0 18 1 95 2 19 3 74 4 25 5 32 \n0 63 1 91 2 75 3 73 4 85 5 20 \n0 69 1 74 2 72 3 47 4 18 5 62 \n0 14 1 66 2 32 3 52 4 58 5 10 \n0 58 1 99 2 30 3 21 4 8 5 60 \n0 1 1 12 2 55 3 7 4 61 5 12 \n0 52 1 74 2 64 3 46 4 4 5 44 \n0 1 1 97 2 53 3 1 4 81 5 32 \n0 6 1 55 2 76 3 12 4 7 5 15 \n0 58 1 20 2 2 3 64 4 51 5 39 \n0 60 1 66 2 33 3 100 4 18 5 81 \n0 71 1 49 2 24 3 56 4 91 5 62 \n0 47 1 49 2 46 3 70 4 32 5 75 \n0 46 1 55 2 82 3 10 4 6 5 96 \n0 33 1 64 2 88 3 97 4 33 5 70 \n0 83 1 87 2 58 3 77 4 30 5 68 \n0 31 1 67 2 63 3 49 4 53 5 59 \n0 94 1 32 2 2 3 6 4 69 5 35 \n0 72 1 15 2 11 3 23 4 30 5 54 \n0 85 1 100 2 89 3 22 4 80 5 8 \n0 19 1 15 2 60 3 57 4 41 5 96 \n" }, { "path": "examples/user_fssp_gls/TrainingData/37.txt", "content": "50 8\n0 7 1 83 2 63 3 69 4 98 5 43 6 20 7 95 \n0 61 1 87 2 32 3 4 4 75 5 41 6 55 7 5 \n0 82 1 51 2 45 3 90 4 88 5 34 6 33 7 51 \n0 10 1 25 2 53 3 26 4 83 5 86 6 4 7 64 \n0 13 1 12 2 90 3 69 4 83 5 49 6 95 7 73 \n0 50 1 44 2 69 3 36 4 88 5 34 6 64 7 89 \n0 56 1 5 2 48 3 49 4 15 5 96 6 86 7 18 \n0 37 1 73 2 70 3 37 4 91 5 13 6 100 7 29 \n0 62 1 79 2 47 3 81 4 5 5 2 6 57 7 63 \n0 96 1 34 2 78 3 26 4 56 5 23 6 15 7 15 \n0 53 1 38 2 81 3 36 4 95 5 4 6 36 7 81 \n0 78 1 96 2 23 3 10 4 25 5 45 6 10 7 45 \n0 15 1 5 2 44 3 46 4 67 5 97 6 36 7 28 \n0 52 1 73 2 54 3 98 4 62 5 16 6 100 7 76 \n0 74 1 84 2 59 3 18 4 6 5 96 6 25 7 90 \n0 39 1 47 2 44 3 52 4 5 5 19 6 97 7 17 \n0 38 1 17 2 35 3 64 4 31 5 89 6 80 7 28 \n0 42 1 20 2 56 3 98 4 6 5 65 6 80 7 89 \n0 40 1 89 2 57 3 61 4 51 5 37 6 72 7 5 \n0 21 1 30 2 28 3 37 4 37 5 1 6 66 7 46 \n0 4 1 15 2 2 3 71 4 12 5 37 6 31 7 94 \n0 97 1 13 2 3 3 27 4 19 5 100 6 89 7 42 \n0 89 1 82 2 70 3 80 4 80 5 55 6 84 7 26 \n0 82 1 59 2 58 3 15 4 30 5 92 6 86 7 6 \n0 70 1 50 2 3 3 36 4 37 5 34 6 67 7 42 \n0 86 1 26 2 53 3 63 4 39 5 40 6 55 7 66 \n0 16 1 91 2 3 3 84 4 39 5 15 6 99 7 66 \n0 33 1 48 2 74 3 36 4 37 5 77 6 33 7 95 \n0 99 1 50 2 68 3 23 4 12 5 78 6 76 7 93 \n0 14 1 14 2 18 3 56 4 60 5 83 6 69 7 75 \n0 82 1 21 2 50 3 55 4 17 5 65 6 37 7 95 \n0 47 1 95 2 72 3 91 4 51 5 40 6 93 7 83 \n0 63 1 19 2 76 3 44 4 50 5 4 6 68 7 30 \n0 58 1 32 2 72 3 99 4 22 5 87 6 44 7 69 \n0 74 1 69 2 37 3 83 4 66 5 71 6 59 7 13 \n0 27 1 20 2 86 3 13 4 78 5 3 6 20 7 49 \n0 56 1 28 2 24 3 76 4 87 5 15 6 39 7 74 \n0 41 1 77 2 4 3 63 4 35 5 97 6 45 7 42 \n0 65 1 44 2 82 3 49 4 28 5 98 6 77 7 76 \n0 50 1 62 2 71 3 13 4 78 5 69 6 38 7 71 \n0 17 1 89 2 49 3 70 4 96 5 13 6 63 7 80 \n0 34 1 3 2 85 3 27 4 75 5 85 6 67 7 92 \n0 36 1 59 2 91 3 41 4 18 5 72 6 24 7 65 \n0 71 1 92 2 3 3 90 4 23 5 12 6 96 7 94 \n0 77 1 84 2 51 3 74 4 11 5 69 6 69 7 20 \n0 55 1 61 2 69 3 62 4 22 5 3 6 89 7 37 \n0 56 1 10 2 83 3 30 4 88 5 27 6 18 7 71 \n0 26 1 9 2 8 3 73 4 43 5 22 6 92 7 3 \n0 46 1 50 2 32 3 49 4 77 5 26 6 85 7 19 \n0 50 1 32 2 53 3 68 4 78 5 39 6 14 7 83 \n" }, { "path": "examples/user_fssp_gls/TrainingData/38.txt", "content": "50 11\n0 73 1 1 2 64 3 95 4 55 5 78 6 72 7 21 8 24 9 81 10 68 \n0 78 1 31 2 98 3 47 4 28 5 68 6 73 7 17 8 98 9 35 10 97 \n0 69 1 65 2 15 3 34 4 2 5 32 6 36 7 31 8 46 9 51 10 58 \n0 62 1 33 2 37 3 10 4 70 5 12 6 1 7 86 8 76 9 52 10 90 \n0 54 1 77 2 5 3 62 4 67 5 71 6 77 7 76 8 7 9 76 10 27 \n0 44 1 20 2 74 3 38 4 61 5 77 6 47 7 28 8 9 9 40 10 21 \n0 97 1 62 2 96 3 15 4 94 5 16 6 76 7 94 8 4 9 8 10 65 \n0 41 1 52 2 93 3 72 4 80 5 73 6 36 7 55 8 99 9 2 10 73 \n0 6 1 20 2 31 3 92 4 66 5 35 6 68 7 17 8 32 9 38 10 78 \n0 22 1 18 2 66 3 13 4 20 5 61 6 13 7 24 8 57 9 11 10 65 \n0 41 1 90 2 36 3 3 4 67 5 89 6 30 7 91 8 46 9 29 10 38 \n0 8 1 50 2 81 3 48 4 87 5 62 6 65 7 31 8 10 9 9 10 99 \n0 45 1 5 2 27 3 11 4 56 5 2 6 10 7 66 8 71 9 72 10 97 \n0 41 1 71 2 64 3 52 4 18 5 2 6 73 7 43 8 32 9 5 10 2 \n0 23 1 13 2 57 3 28 4 59 5 13 6 81 7 34 8 26 9 87 10 41 \n0 77 1 11 2 4 3 15 4 18 5 28 6 57 7 74 8 70 9 74 10 95 \n0 83 1 97 2 90 3 27 4 83 5 49 6 14 7 75 8 44 9 6 10 53 \n0 10 1 72 2 84 3 50 4 29 5 82 6 67 7 54 8 63 9 20 10 4 \n0 7 1 50 2 95 3 63 4 63 5 13 6 57 7 21 8 75 9 39 10 35 \n0 10 1 74 2 10 3 98 4 53 5 55 6 32 7 96 8 58 9 74 10 84 \n0 28 1 94 2 19 3 80 4 5 5 16 6 46 7 80 8 96 9 1 10 99 \n0 14 1 76 2 100 3 30 4 95 5 98 6 83 7 14 8 91 9 15 10 59 \n0 78 1 74 2 10 3 26 4 17 5 1 6 92 7 71 8 24 9 67 10 9 \n0 15 1 67 2 47 3 12 4 60 5 69 6 4 7 73 8 75 9 74 10 7 \n0 100 1 32 2 80 3 32 4 1 5 67 6 23 7 96 8 79 9 53 10 46 \n0 60 1 58 2 43 3 51 4 98 5 98 6 75 7 89 8 59 9 67 10 13 \n0 36 1 67 2 44 3 71 4 94 5 74 6 74 7 92 8 86 9 72 10 13 \n0 26 1 84 2 15 3 16 4 73 5 5 6 68 7 28 8 99 9 45 10 54 \n0 17 1 40 2 84 3 10 4 56 5 23 6 78 7 52 8 88 9 79 10 57 \n0 96 1 60 2 34 3 82 4 98 5 49 6 94 7 51 8 32 9 93 10 41 \n0 29 1 47 2 70 3 10 4 71 5 82 6 64 7 64 8 50 9 63 10 71 \n0 77 1 75 2 75 3 23 4 100 5 66 6 33 7 72 8 67 9 22 10 11 \n0 92 1 97 2 44 3 34 4 33 5 69 6 66 7 59 8 8 9 86 10 39 \n0 59 1 48 2 90 3 8 4 31 5 74 6 45 7 64 8 74 9 49 10 22 \n0 83 1 47 2 96 3 70 4 76 5 79 6 70 7 44 8 63 9 45 10 22 \n0 65 1 22 2 50 3 36 4 5 5 7 6 17 7 33 8 2 9 33 10 77 \n0 51 1 100 2 39 3 31 4 35 5 9 6 70 7 42 8 1 9 53 10 26 \n0 2 1 35 2 85 3 18 4 38 5 28 6 28 7 9 8 84 9 44 10 44 \n0 51 1 8 2 88 3 17 4 32 5 48 6 44 7 23 8 55 9 17 10 62 \n0 37 1 73 2 36 3 67 4 69 5 50 6 45 7 12 8 24 9 37 10 91 \n0 24 1 44 2 43 3 80 4 76 5 85 6 98 7 11 8 60 9 39 10 88 \n0 23 1 59 2 93 3 15 4 70 5 51 6 43 7 36 8 88 9 8 10 59 \n0 45 1 2 2 12 3 48 4 59 5 48 6 70 7 35 8 79 9 87 10 62 \n0 28 1 27 2 36 3 60 4 7 5 26 6 6 7 19 8 39 9 50 10 47 \n0 67 1 46 2 11 3 79 4 14 5 69 6 91 7 63 8 78 9 64 10 25 \n0 3 1 66 2 69 3 46 4 51 5 97 6 39 7 16 8 94 9 80 10 18 \n0 18 1 95 2 85 3 94 4 91 5 81 6 9 7 38 8 76 9 68 10 80 \n0 100 1 53 2 43 3 59 4 84 5 34 6 40 7 14 8 49 9 29 10 28 \n0 30 1 21 2 8 3 53 4 31 5 67 6 39 7 89 8 46 9 5 10 61 \n0 25 1 52 2 34 3 35 4 13 5 93 6 30 7 34 8 24 9 8 10 77 \n" }, { "path": "examples/user_fssp_gls/TrainingData/39.txt", "content": "50 3\n0 6 1 62 2 2 \n0 48 1 50 2 27 \n0 26 1 87 2 38 \n0 82 1 81 2 27 \n0 87 1 97 2 71 \n0 46 1 31 2 92 \n0 41 1 71 2 68 \n0 19 1 1 2 78 \n0 62 1 23 2 87 \n0 61 1 4 2 5 \n0 73 1 79 2 29 \n0 42 1 70 2 28 \n0 10 1 27 2 3 \n0 12 1 18 2 72 \n0 64 1 65 2 12 \n0 79 1 37 2 5 \n0 42 1 17 2 71 \n0 15 1 52 2 82 \n0 12 1 80 2 19 \n0 12 1 27 2 86 \n0 94 1 49 2 37 \n0 72 1 92 2 9 \n0 52 1 74 2 39 \n0 6 1 78 2 46 \n0 46 1 97 2 100 \n0 98 1 55 2 79 \n0 61 1 7 2 55 \n0 3 1 84 2 99 \n0 26 1 9 2 57 \n0 63 1 78 2 50 \n0 43 1 94 2 48 \n0 38 1 97 2 87 \n0 8 1 15 2 66 \n0 2 1 18 2 96 \n0 67 1 87 2 35 \n0 56 1 93 2 83 \n0 51 1 93 2 63 \n0 76 1 6 2 25 \n0 13 1 31 2 22 \n0 84 1 60 2 81 \n0 89 1 97 2 48 \n0 72 1 67 2 6 \n0 11 1 54 2 43 \n0 54 1 100 2 51 \n0 82 1 31 2 35 \n0 32 1 21 2 59 \n0 9 1 49 2 99 \n0 75 1 54 2 99 \n0 1 1 66 2 70 \n0 49 1 24 2 57 \n" }, { "path": "examples/user_fssp_gls/TrainingData/4.txt", "content": "50 3\n0 49 1 15 2 32 \n0 81 1 17 2 16 \n0 44 1 45 2 43 \n0 73 1 47 2 78 \n0 92 1 79 2 49 \n0 68 1 83 2 1 \n0 30 1 2 2 81 \n0 38 1 70 2 53 \n0 19 1 86 2 21 \n0 67 1 43 2 55 \n0 17 1 39 2 59 \n0 28 1 74 2 14 \n0 56 1 55 2 18 \n0 94 1 84 2 5 \n0 60 1 59 2 96 \n0 34 1 25 2 9 \n0 9 1 16 2 93 \n0 40 1 67 2 51 \n0 22 1 27 2 17 \n0 44 1 80 2 12 \n0 74 1 55 2 61 \n0 63 1 93 2 66 \n0 36 1 20 2 18 \n0 63 1 72 2 3 \n0 22 1 56 2 39 \n0 21 1 96 2 26 \n0 94 1 77 2 47 \n0 52 1 83 2 47 \n0 2 1 50 2 90 \n0 88 1 24 2 88 \n0 59 1 57 2 17 \n0 15 1 96 2 36 \n0 45 1 32 2 23 \n0 44 1 60 2 58 \n0 20 1 9 2 30 \n0 64 1 51 2 99 \n0 55 1 11 2 94 \n0 20 1 30 2 5 \n0 33 1 50 2 76 \n0 86 1 100 2 33 \n0 83 1 93 2 89 \n0 83 1 14 2 56 \n0 39 1 75 2 95 \n0 28 1 51 2 66 \n0 24 1 95 2 20 \n0 78 1 79 2 95 \n0 21 1 65 2 69 \n0 39 1 67 2 53 \n0 86 1 16 2 33 \n0 81 1 87 2 82 \n" }, { "path": "examples/user_fssp_gls/TrainingData/40.txt", "content": "50 19\n0 74 1 70 2 33 3 95 4 1 5 84 6 1 7 6 8 22 9 87 10 29 11 85 12 11 13 70 14 30 15 51 16 11 17 51 18 12 \n0 29 1 11 2 52 3 47 4 86 5 16 6 82 7 53 8 49 9 96 10 59 11 49 12 94 13 57 14 37 15 76 16 100 17 29 18 48 \n0 45 1 79 2 3 3 100 4 46 5 5 6 24 7 72 8 52 9 78 10 52 11 53 12 69 13 72 14 76 15 44 16 11 17 32 18 47 \n0 26 1 92 2 3 3 18 4 20 5 67 6 75 7 18 8 15 9 40 10 98 11 21 12 73 13 10 14 63 15 15 16 6 17 24 18 36 \n0 79 1 97 2 4 3 32 4 24 5 43 6 56 7 64 8 83 9 38 10 13 11 26 12 100 13 81 14 27 15 68 16 54 17 27 18 71 \n0 57 1 20 2 30 3 22 4 15 5 100 6 96 7 28 8 10 9 32 10 78 11 55 12 3 13 58 14 66 15 99 16 14 17 97 18 46 \n0 77 1 64 2 52 3 85 4 59 5 85 6 87 7 57 8 43 9 30 10 25 11 48 12 51 13 45 14 10 15 82 16 22 17 70 18 63 \n0 14 1 86 2 61 3 66 4 67 5 81 6 43 7 44 8 58 9 11 10 46 11 42 12 86 13 96 14 65 15 33 16 32 17 100 18 78 \n0 85 1 71 2 76 3 93 4 65 5 97 6 87 7 10 8 14 9 49 10 68 11 62 12 9 13 95 14 6 15 67 16 64 17 62 18 90 \n0 75 1 12 2 30 3 24 4 95 5 31 6 51 7 72 8 58 9 98 10 2 11 24 12 59 13 2 14 84 15 30 16 66 17 64 18 55 \n0 80 1 30 2 16 3 55 4 6 5 81 6 62 7 56 8 57 9 36 10 3 11 39 12 2 13 15 14 6 15 91 16 73 17 78 18 57 \n0 66 1 15 2 71 3 80 4 13 5 17 6 49 7 35 8 62 9 29 10 72 11 79 12 70 13 62 14 52 15 37 16 28 17 26 18 51 \n0 23 1 97 2 56 3 5 4 89 5 40 6 55 7 72 8 54 9 6 10 57 11 28 12 67 13 91 14 31 15 7 16 12 17 57 18 33 \n0 99 1 89 2 31 3 91 4 98 5 56 6 73 7 61 8 17 9 29 10 85 11 13 12 27 13 9 14 4 15 32 16 30 17 96 18 67 \n0 24 1 98 2 86 3 38 4 95 5 39 6 72 7 81 8 35 9 35 10 4 11 17 12 50 13 3 14 39 15 19 16 65 17 41 18 92 \n0 96 1 43 2 45 3 31 4 52 5 98 6 74 7 95 8 58 9 50 10 9 11 61 12 31 13 43 14 18 15 65 16 73 17 85 18 71 \n0 19 1 10 2 42 3 37 4 69 5 55 6 44 7 29 8 26 9 60 10 35 11 14 12 94 13 79 14 74 15 94 16 32 17 36 18 92 \n0 19 1 31 2 78 3 7 4 80 5 87 6 26 7 45 8 57 9 1 10 72 11 98 12 22 13 25 14 22 15 47 16 82 17 86 18 100 \n0 7 1 34 2 8 3 66 4 97 5 83 6 5 7 20 8 12 9 82 10 20 11 25 12 89 13 21 14 14 15 44 16 95 17 15 18 35 \n0 44 1 69 2 78 3 20 4 95 5 81 6 75 7 24 8 77 9 72 10 50 11 9 12 67 13 25 14 10 15 62 16 91 17 83 18 62 \n0 76 1 14 2 71 3 1 4 46 5 34 6 44 7 83 8 68 9 14 10 97 11 9 12 83 13 94 14 98 15 94 16 76 17 48 18 39 \n0 54 1 76 2 69 3 44 4 26 5 44 6 9 7 52 8 45 9 80 10 33 11 32 12 91 13 15 14 61 15 53 16 95 17 78 18 21 \n0 31 1 7 2 50 3 7 4 25 5 49 6 50 7 43 8 92 9 60 10 89 11 62 12 71 13 72 14 18 15 46 16 74 17 55 18 23 \n0 82 1 41 2 98 3 16 4 21 5 42 6 12 7 43 8 18 9 38 10 55 11 43 12 41 13 60 14 3 15 83 16 100 17 18 18 94 \n0 22 1 47 2 21 3 67 4 73 5 21 6 44 7 70 8 55 9 74 10 16 11 17 12 73 13 57 14 24 15 68 16 87 17 7 18 77 \n0 4 1 5 2 17 3 45 4 94 5 40 6 96 7 2 8 70 9 44 10 2 11 30 12 37 13 70 14 88 15 12 16 14 17 27 18 7 \n0 49 1 90 2 33 3 16 4 20 5 4 6 93 7 75 8 35 9 18 10 28 11 85 12 18 13 68 14 43 15 18 16 42 17 61 18 27 \n0 82 1 12 2 6 3 85 4 89 5 2 6 56 7 40 8 5 9 56 10 100 11 79 12 23 13 66 14 52 15 51 16 52 17 42 18 32 \n0 87 1 37 2 29 3 79 4 7 5 35 6 68 7 82 8 86 9 9 10 94 11 56 12 70 13 66 14 78 15 19 16 89 17 53 18 3 \n0 7 1 58 2 59 3 59 4 60 5 24 6 60 7 34 8 47 9 68 10 87 11 44 12 1 13 12 14 93 15 92 16 51 17 49 18 33 \n0 23 1 83 2 55 3 18 4 81 5 93 6 46 7 77 8 66 9 73 10 1 11 44 12 29 13 17 14 50 15 41 16 91 17 82 18 79 \n0 7 1 75 2 78 3 31 4 86 5 20 6 86 7 15 8 33 9 81 10 79 11 78 12 55 13 59 14 45 15 100 16 58 17 25 18 51 \n0 57 1 16 2 71 3 28 4 81 5 28 6 90 7 12 8 31 9 22 10 54 11 15 12 9 13 10 14 8 15 87 16 49 17 45 18 56 \n0 90 1 83 2 78 3 100 4 97 5 64 6 83 7 23 8 54 9 90 10 27 11 40 12 11 13 36 14 4 15 38 16 10 17 78 18 68 \n0 20 1 50 2 100 3 51 4 50 5 60 6 63 7 11 8 87 9 46 10 92 11 37 12 9 13 85 14 15 15 6 16 88 17 84 18 51 \n0 64 1 59 2 60 3 71 4 86 5 25 6 49 7 37 8 53 9 61 10 86 11 74 12 60 13 96 14 29 15 69 16 65 17 81 18 61 \n0 1 1 86 2 92 3 89 4 45 5 75 6 87 7 72 8 79 9 5 10 31 11 1 12 45 13 67 14 59 15 91 16 38 17 50 18 84 \n0 96 1 72 2 6 3 95 4 20 5 52 6 39 7 59 8 54 9 83 10 15 11 49 12 34 13 26 14 78 15 7 16 34 17 8 18 50 \n0 75 1 2 2 27 3 84 4 3 5 98 6 50 7 31 8 80 9 26 10 75 11 52 12 89 13 91 14 85 15 29 16 19 17 75 18 96 \n0 78 1 13 2 13 3 45 4 24 5 9 6 58 7 8 8 4 9 64 10 97 11 87 12 15 13 92 14 53 15 21 16 100 17 67 18 27 \n0 6 1 20 2 8 3 82 4 32 5 9 6 31 7 20 8 11 9 31 10 50 11 25 12 31 13 14 14 5 15 94 16 73 17 21 18 45 \n0 16 1 5 2 82 3 87 4 54 5 10 6 16 7 41 8 41 9 11 10 85 11 53 12 67 13 94 14 61 15 19 16 61 17 10 18 58 \n0 9 1 15 2 21 3 19 4 50 5 30 6 97 7 20 8 66 9 42 10 79 11 85 12 9 13 63 14 99 15 35 16 35 17 46 18 96 \n0 77 1 69 2 34 3 96 4 53 5 13 6 48 7 23 8 70 9 17 10 92 11 64 12 64 13 59 14 87 15 73 16 52 17 15 18 39 \n0 12 1 54 2 45 3 94 4 14 5 54 6 13 7 41 8 93 9 24 10 83 11 83 12 91 13 97 14 18 15 61 16 76 17 74 18 89 \n0 17 1 34 2 7 3 32 4 55 5 85 6 83 7 14 8 46 9 67 10 31 11 21 12 94 13 20 14 56 15 6 16 51 17 32 18 10 \n0 27 1 87 2 20 3 66 4 23 5 7 6 18 7 86 8 78 9 86 10 50 11 71 12 39 13 14 14 61 15 43 16 11 17 29 18 48 \n0 82 1 47 2 34 3 1 4 39 5 100 6 43 7 43 8 91 9 4 10 77 11 46 12 71 13 50 14 48 15 84 16 4 17 89 18 81 \n0 72 1 88 2 44 3 43 4 97 5 8 6 46 7 82 8 53 9 82 10 68 11 74 12 77 13 17 14 85 15 62 16 98 17 8 18 8 \n0 54 1 59 2 7 3 18 4 74 5 87 6 15 7 2 8 62 9 72 10 19 11 47 12 59 13 91 14 98 15 69 16 68 17 35 18 39 \n" }, { "path": "examples/user_fssp_gls/TrainingData/41.txt", "content": "50 20\n0 47 1 49 2 45 3 90 4 99 5 21 6 89 7 46 8 50 9 20 10 22 11 38 12 67 13 48 14 71 15 90 16 79 17 17 18 61 19 44 \n0 62 1 46 2 49 3 41 4 76 5 97 6 91 7 98 8 11 9 44 10 36 11 14 12 6 13 30 14 13 15 90 16 3 17 2 18 36 19 5 \n0 29 1 31 2 38 3 97 4 58 5 20 6 77 7 86 8 98 9 86 10 60 11 22 12 25 13 78 14 29 15 66 16 19 17 77 18 31 19 67 \n0 55 1 79 2 70 3 48 4 46 5 34 6 10 7 18 8 54 9 40 10 93 11 17 12 87 13 88 14 67 15 7 16 73 17 60 18 100 19 74 \n0 42 1 84 2 30 3 86 4 85 5 22 6 44 7 1 8 75 9 55 10 85 11 8 12 66 13 51 14 93 15 68 16 61 17 36 18 74 19 78 \n0 9 1 19 2 21 3 95 4 75 5 88 6 1 7 83 8 85 9 37 10 41 11 22 12 12 13 39 14 52 15 73 16 89 17 34 18 36 19 74 \n0 69 1 93 2 72 3 37 4 88 5 95 6 23 7 55 8 89 9 31 10 37 11 61 12 38 13 9 14 40 15 36 16 99 17 36 18 42 19 87 \n0 10 1 3 2 79 3 5 4 49 5 49 6 94 7 88 8 96 9 37 10 20 11 71 12 69 13 45 14 83 15 58 16 61 17 11 18 13 19 63 \n0 34 1 64 2 96 3 56 4 91 5 13 6 16 7 74 8 99 9 28 10 71 11 80 12 24 13 65 14 51 15 90 16 26 17 20 18 77 19 42 \n0 78 1 22 2 46 3 28 4 89 5 40 6 18 7 31 8 55 9 98 10 73 11 73 12 31 13 29 14 87 15 70 16 43 17 6 18 52 19 61 \n0 90 1 71 2 95 3 54 4 5 5 39 6 43 7 82 8 77 9 64 10 99 11 5 12 65 13 73 14 12 15 86 16 71 17 74 18 51 19 42 \n0 82 1 49 2 40 3 51 4 22 5 47 6 46 7 40 8 65 9 23 10 88 11 66 12 65 13 44 14 82 15 83 16 25 17 78 18 31 19 78 \n0 100 1 68 2 88 3 4 4 10 5 94 6 20 7 91 8 47 9 3 10 68 11 94 12 68 13 39 14 26 15 96 16 16 17 49 18 63 19 3 \n0 39 1 72 2 39 3 66 4 74 5 26 6 10 7 27 8 53 9 44 10 33 11 49 12 76 13 85 14 98 15 92 16 47 17 98 18 20 19 10 \n0 45 1 34 2 70 3 11 4 31 5 93 6 25 7 1 8 93 9 99 10 32 11 14 12 83 13 85 14 95 15 4 16 72 17 64 18 22 19 79 \n0 96 1 42 2 31 3 85 4 74 5 53 6 76 7 57 8 10 9 10 10 88 11 95 12 67 13 73 14 73 15 75 16 73 17 72 18 88 19 83 \n0 40 1 79 2 92 3 68 4 71 5 58 6 45 7 50 8 57 9 50 10 95 11 20 12 51 13 82 14 54 15 24 16 89 17 81 18 16 19 66 \n0 98 1 7 2 89 3 62 4 23 5 23 6 19 7 46 8 15 9 73 10 57 11 7 12 72 13 22 14 96 15 68 16 100 17 81 18 73 19 3 \n0 51 1 29 2 90 3 20 4 32 5 92 6 66 7 87 8 63 9 48 10 100 11 68 12 59 13 53 14 71 15 39 16 30 17 12 18 4 19 96 \n0 13 1 62 2 31 3 18 4 49 5 76 6 9 7 55 8 54 9 26 10 62 11 92 12 75 13 100 14 14 15 74 16 44 17 21 18 86 19 35 \n0 88 1 62 2 48 3 35 4 64 5 28 6 58 7 78 8 28 9 21 10 53 11 88 12 53 13 33 14 99 15 87 16 57 17 100 18 52 19 98 \n0 55 1 97 2 19 3 72 4 73 5 1 6 4 7 11 8 45 9 66 10 90 11 43 12 69 13 50 14 26 15 75 16 47 17 1 18 35 19 85 \n0 59 1 3 2 50 3 57 4 72 5 7 6 88 7 75 8 59 9 57 10 76 11 88 12 78 13 38 14 18 15 74 16 74 17 23 18 69 19 54 \n0 31 1 98 2 69 3 1 4 97 5 1 6 43 7 37 8 48 9 14 10 40 11 2 12 91 13 11 14 17 15 89 16 53 17 5 18 89 19 94 \n0 35 1 2 2 28 3 97 4 78 5 62 6 63 7 64 8 18 9 15 10 35 11 47 12 95 13 100 14 94 15 44 16 17 17 37 18 66 19 22 \n0 30 1 77 2 64 3 85 4 50 5 50 6 99 7 33 8 67 9 41 10 60 11 22 12 23 13 67 14 77 15 8 16 41 17 65 18 16 19 65 \n0 30 1 91 2 88 3 79 4 94 5 31 6 100 7 86 8 38 9 18 10 68 11 70 12 37 13 49 14 62 15 86 16 68 17 29 18 97 19 68 \n0 53 1 39 2 75 3 31 4 75 5 36 6 94 7 74 8 73 9 47 10 21 11 67 12 1 13 27 14 74 15 22 16 2 17 46 18 100 19 95 \n0 44 1 65 2 4 3 71 4 98 5 60 6 11 7 2 8 87 9 28 10 46 11 29 12 63 13 93 14 76 15 13 16 84 17 15 18 37 19 37 \n0 76 1 96 2 85 3 35 4 50 5 48 6 16 7 65 8 47 9 75 10 42 11 17 12 2 13 7 14 6 15 40 16 72 17 38 18 97 19 2 \n0 55 1 8 2 88 3 6 4 45 5 12 6 13 7 41 8 39 9 49 10 62 11 97 12 56 13 17 14 1 15 80 16 89 17 83 18 93 19 27 \n0 19 1 65 2 100 3 83 4 8 5 43 6 83 7 75 8 29 9 76 10 75 11 88 12 47 13 13 14 38 15 51 16 20 17 62 18 87 19 68 \n0 79 1 54 2 75 3 86 4 29 5 76 6 30 7 60 8 88 9 68 10 16 11 56 12 22 13 59 14 34 15 77 16 31 17 38 18 2 19 96 \n0 10 1 65 2 98 3 17 4 25 5 30 6 72 7 11 8 16 9 2 10 28 11 36 12 37 13 31 14 60 15 93 16 12 17 73 18 10 19 39 \n0 34 1 40 2 19 3 24 4 21 5 97 6 75 7 68 8 89 9 97 10 15 11 67 12 38 13 34 14 26 15 3 16 21 17 23 18 76 19 78 \n0 4 1 40 2 33 3 6 4 86 5 21 6 5 7 3 8 96 9 85 10 84 11 33 12 30 13 53 14 97 15 51 16 55 17 78 18 76 19 29 \n0 47 1 25 2 52 3 53 4 66 5 24 6 77 7 81 8 82 9 11 10 9 11 89 12 10 13 16 14 28 15 87 16 51 17 43 18 42 19 41 \n0 50 1 78 2 49 3 6 4 76 5 65 6 4 7 57 8 14 9 23 10 64 11 56 12 3 13 51 14 92 15 94 16 79 17 2 18 5 19 33 \n0 77 1 41 2 50 3 54 4 32 5 36 6 72 7 51 8 79 9 67 10 33 11 75 12 70 13 10 14 66 15 83 16 62 17 69 18 60 19 100 \n0 76 1 11 2 97 3 46 4 55 5 9 6 3 7 8 8 77 9 6 10 5 11 55 12 17 13 21 14 20 15 49 16 51 17 59 18 74 19 27 \n0 9 1 45 2 58 3 28 4 9 5 91 6 20 7 42 8 76 9 59 10 86 11 13 12 37 13 28 14 98 15 35 16 80 17 42 18 53 19 66 \n0 64 1 3 2 94 3 13 4 32 5 23 6 10 7 28 8 59 9 15 10 86 11 66 12 17 13 96 14 82 15 26 16 33 17 16 18 30 19 60 \n0 91 1 42 2 93 3 45 4 75 5 36 6 78 7 97 8 78 9 46 10 49 11 18 12 80 13 79 14 43 15 94 16 94 17 51 18 76 19 30 \n0 55 1 20 2 94 3 50 4 1 5 49 6 65 7 53 8 51 9 43 10 91 11 2 12 58 13 59 14 86 15 82 16 96 17 68 18 75 19 1 \n0 88 1 74 2 46 3 29 4 77 5 19 6 30 7 10 8 79 9 85 10 72 11 7 12 70 13 70 14 10 15 31 16 60 17 28 18 22 19 82 \n0 21 1 73 2 60 3 10 4 39 5 8 6 21 7 42 8 78 9 68 10 29 11 55 12 2 13 22 14 89 15 48 16 89 17 66 18 42 19 24 \n0 24 1 93 2 26 3 24 4 79 5 85 6 9 7 42 8 42 9 59 10 44 11 77 12 82 13 13 14 40 15 77 16 14 17 4 18 80 19 27 \n0 17 1 84 2 60 3 63 4 2 5 2 6 56 7 29 8 53 9 86 10 71 11 59 12 51 13 83 14 85 15 84 16 27 17 46 18 57 19 43 \n0 23 1 25 2 94 3 76 4 24 5 45 6 21 7 72 8 67 9 75 10 11 11 2 12 21 13 76 14 36 15 65 16 67 17 63 18 78 19 92 \n0 12 1 46 2 81 3 75 4 62 5 97 6 60 7 38 8 26 9 29 10 84 11 93 12 34 13 3 14 92 15 88 16 2 17 11 18 12 19 21 \n" }, { "path": "examples/user_fssp_gls/TrainingData/42.txt", "content": "50 8\n0 74 1 26 2 38 3 82 4 76 5 66 6 40 7 53 \n0 49 1 90 2 23 3 56 4 76 5 4 6 74 7 85 \n0 75 1 76 2 42 3 4 4 9 5 49 6 66 7 64 \n0 45 1 78 2 55 3 98 4 53 5 18 6 89 7 83 \n0 38 1 25 2 17 3 20 4 44 5 7 6 4 7 78 \n0 5 1 49 2 26 3 14 4 11 5 42 6 77 7 26 \n0 75 1 24 2 42 3 50 4 26 5 38 6 61 7 75 \n0 90 1 9 2 86 3 66 4 43 5 24 6 31 7 63 \n0 73 1 7 2 26 3 48 4 93 5 80 6 88 7 2 \n0 58 1 38 2 1 3 76 4 24 5 90 6 57 7 40 \n0 99 1 75 2 80 3 72 4 44 5 36 6 68 7 90 \n0 13 1 97 2 58 3 92 4 33 5 3 6 62 7 50 \n0 57 1 8 2 29 3 22 4 78 5 62 6 29 7 39 \n0 100 1 50 2 37 3 69 4 42 5 70 6 66 7 56 \n0 82 1 3 2 35 3 83 4 72 5 40 6 93 7 59 \n0 59 1 11 2 28 3 53 4 80 5 37 6 13 7 31 \n0 77 1 4 2 39 3 16 4 78 5 40 6 95 7 11 \n0 88 1 97 2 9 3 100 4 70 5 74 6 10 7 24 \n0 97 1 46 2 55 3 25 4 54 5 13 6 84 7 7 \n0 24 1 92 2 96 3 37 4 42 5 23 6 38 7 64 \n0 36 1 65 2 23 3 14 4 26 5 37 6 27 7 52 \n0 52 1 57 2 78 3 37 4 81 5 85 6 77 7 76 \n0 59 1 24 2 18 3 77 4 73 5 25 6 49 7 69 \n0 83 1 97 2 68 3 27 4 3 5 85 6 92 7 62 \n0 43 1 17 2 30 3 87 4 2 5 57 6 57 7 99 \n0 2 1 66 2 83 3 91 4 32 5 57 6 3 7 64 \n0 45 1 72 2 46 3 73 4 66 5 59 6 73 7 25 \n0 3 1 31 2 95 3 11 4 55 5 16 6 23 7 48 \n0 67 1 72 2 57 3 70 4 97 5 62 6 12 7 95 \n0 9 1 81 2 8 3 93 4 84 5 42 6 68 7 4 \n0 34 1 65 2 66 3 24 4 78 5 92 6 25 7 20 \n0 7 1 62 2 25 3 24 4 77 5 67 6 64 7 42 \n0 21 1 73 2 56 3 47 4 5 5 9 6 94 7 81 \n0 32 1 98 2 68 3 71 4 26 5 20 6 38 7 79 \n0 16 1 18 2 36 3 60 4 33 5 56 6 38 7 15 \n0 54 1 99 2 32 3 60 4 24 5 71 6 37 7 42 \n0 7 1 48 2 10 3 9 4 45 5 82 6 95 7 93 \n0 63 1 83 2 8 3 83 4 39 5 25 6 2 7 46 \n0 59 1 56 2 96 3 75 4 23 5 72 6 79 7 42 \n0 31 1 33 2 48 3 49 4 72 5 80 6 10 7 64 \n0 85 1 16 2 86 3 72 4 53 5 94 6 89 7 8 \n0 31 1 36 2 84 3 6 4 63 5 18 6 64 7 95 \n0 90 1 11 2 19 3 39 4 44 5 55 6 69 7 100 \n0 91 1 38 2 58 3 59 4 59 5 81 6 43 7 78 \n0 28 1 46 2 29 3 85 4 12 5 2 6 28 7 89 \n0 71 1 48 2 24 3 62 4 18 5 88 6 25 7 93 \n0 5 1 81 2 6 3 57 4 17 5 25 6 72 7 48 \n0 40 1 39 2 24 3 53 4 23 5 10 6 9 7 50 \n0 17 1 11 2 73 3 65 4 75 5 3 6 52 7 2 \n0 46 1 20 2 13 3 81 4 40 5 60 6 72 7 20 \n" }, { "path": "examples/user_fssp_gls/TrainingData/43.txt", "content": "50 11\n0 45 1 78 2 34 3 89 4 76 5 41 6 65 7 9 8 42 9 32 10 57 \n0 27 1 29 2 35 3 79 4 90 5 17 6 99 7 12 8 65 9 28 10 3 \n0 65 1 34 2 49 3 19 4 78 5 96 6 38 7 30 8 73 9 71 10 74 \n0 30 1 25 2 31 3 55 4 72 5 69 6 2 7 9 8 13 9 83 10 90 \n0 57 1 8 2 38 3 7 4 17 5 34 6 10 7 35 8 36 9 95 10 43 \n0 47 1 77 2 12 3 36 4 28 5 24 6 33 7 23 8 81 9 51 10 71 \n0 3 1 38 2 85 3 90 4 91 5 76 6 49 7 35 8 45 9 76 10 23 \n0 10 1 72 2 32 3 19 4 3 5 52 6 98 7 58 8 22 9 69 10 19 \n0 61 1 62 2 78 3 100 4 53 5 81 6 38 7 88 8 48 9 52 10 26 \n0 85 1 62 2 86 3 28 4 40 5 58 6 25 7 11 8 61 9 91 10 80 \n0 65 1 60 2 69 3 40 4 71 5 71 6 80 7 66 8 62 9 78 10 57 \n0 85 1 19 2 75 3 53 4 99 5 52 6 71 7 33 8 70 9 64 10 96 \n0 13 1 4 2 67 3 64 4 6 5 31 6 4 7 81 8 77 9 17 10 50 \n0 99 1 2 2 21 3 33 4 66 5 92 6 72 7 2 8 57 9 57 10 9 \n0 47 1 83 2 17 3 76 4 20 5 30 6 73 7 51 8 74 9 53 10 96 \n0 86 1 30 2 25 3 94 4 6 5 14 6 78 7 99 8 3 9 97 10 10 \n0 2 1 57 2 56 3 43 4 34 5 45 6 5 7 66 8 94 9 79 10 52 \n0 44 1 54 2 43 3 70 4 51 5 67 6 90 7 68 8 16 9 44 10 13 \n0 7 1 93 2 86 3 48 4 66 5 46 6 76 7 87 8 64 9 53 10 84 \n0 24 1 57 2 44 3 14 4 75 5 63 6 69 7 54 8 26 9 49 10 26 \n0 75 1 31 2 83 3 55 4 95 5 88 6 55 7 1 8 64 9 61 10 42 \n0 68 1 82 2 1 3 28 4 81 5 66 6 39 7 23 8 67 9 29 10 92 \n0 15 1 75 2 65 3 95 4 3 5 50 6 4 7 13 8 43 9 57 10 59 \n0 6 1 88 2 55 3 19 4 67 5 46 6 29 7 62 8 58 9 50 10 49 \n0 90 1 46 2 26 3 40 4 55 5 5 6 15 7 25 8 84 9 92 10 76 \n0 41 1 49 2 94 3 84 4 26 5 28 6 39 7 66 8 65 9 78 10 80 \n0 52 1 54 2 6 3 47 4 51 5 59 6 42 7 28 8 51 9 24 10 26 \n0 76 1 61 2 57 3 93 4 3 5 32 6 64 7 42 8 88 9 38 10 45 \n0 52 1 37 2 60 3 25 4 95 5 85 6 10 7 69 8 49 9 33 10 46 \n0 63 1 23 2 41 3 14 4 19 5 76 6 21 7 7 8 44 9 12 10 77 \n0 97 1 96 2 49 3 56 4 32 5 13 6 1 7 45 8 40 9 12 10 66 \n0 13 1 81 2 17 3 72 4 17 5 86 6 1 7 98 8 21 9 17 10 35 \n0 32 1 84 2 16 3 26 4 27 5 28 6 40 7 96 8 19 9 60 10 22 \n0 40 1 45 2 45 3 66 4 53 5 7 6 96 7 61 8 72 9 5 10 36 \n0 68 1 45 2 76 3 85 4 46 5 70 6 28 7 73 8 11 9 12 10 78 \n0 12 1 44 2 85 3 38 4 83 5 21 6 63 7 100 8 70 9 90 10 98 \n0 86 1 3 2 44 3 32 4 88 5 4 6 95 7 14 8 71 9 14 10 79 \n0 71 1 22 2 20 3 5 4 28 5 67 6 44 7 72 8 82 9 81 10 92 \n0 44 1 40 2 74 3 64 4 10 5 76 6 92 7 63 8 13 9 93 10 61 \n0 50 1 81 2 49 3 91 4 39 5 17 6 97 7 32 8 62 9 53 10 62 \n0 88 1 80 2 56 3 8 4 1 5 64 6 76 7 23 8 4 9 18 10 4 \n0 5 1 100 2 85 3 65 4 24 5 68 6 92 7 56 8 42 9 77 10 68 \n0 77 1 65 2 3 3 57 4 50 5 94 6 73 7 89 8 23 9 34 10 76 \n0 55 1 70 2 3 3 61 4 11 5 42 6 61 7 92 8 12 9 59 10 71 \n0 87 1 16 2 70 3 19 4 65 5 17 6 84 7 39 8 23 9 70 10 18 \n0 11 1 44 2 19 3 82 4 54 5 5 6 27 7 18 8 45 9 11 10 3 \n0 58 1 85 2 75 3 24 4 57 5 41 6 81 7 36 8 32 9 74 10 5 \n0 91 1 97 2 11 3 84 4 85 5 72 6 60 7 33 8 17 9 63 10 10 \n0 78 1 85 2 21 3 30 4 89 5 69 6 95 7 60 8 59 9 47 10 52 \n0 15 1 37 2 78 3 37 4 51 5 63 6 14 7 62 8 82 9 26 10 28 \n" }, { "path": "examples/user_fssp_gls/TrainingData/44.txt", "content": "50 7\n0 18 1 75 2 38 3 24 4 80 5 95 6 56 \n0 1 1 20 2 68 3 18 4 18 5 83 6 77 \n0 10 1 79 2 66 3 83 4 88 5 82 6 74 \n0 31 1 45 2 20 3 23 4 64 5 95 6 10 \n0 61 1 94 2 38 3 63 4 99 5 77 6 90 \n0 11 1 11 2 9 3 92 4 48 5 26 6 56 \n0 59 1 21 2 1 3 49 4 65 5 58 6 47 \n0 82 1 61 2 47 3 39 4 2 5 65 6 79 \n0 35 1 60 2 80 3 80 4 10 5 44 6 25 \n0 75 1 73 2 43 3 96 4 66 5 4 6 39 \n0 50 1 31 2 100 3 66 4 77 5 41 6 62 \n0 59 1 11 2 89 3 81 4 83 5 36 6 19 \n0 60 1 51 2 98 3 29 4 69 5 52 6 22 \n0 31 1 8 2 95 3 75 4 9 5 26 6 4 \n0 17 1 24 2 85 3 85 4 17 5 17 6 8 \n0 51 1 28 2 91 3 51 4 77 5 10 6 95 \n0 80 1 61 2 94 3 7 4 27 5 27 6 5 \n0 71 1 44 2 29 3 14 4 8 5 32 6 5 \n0 18 1 23 2 73 3 11 4 68 5 77 6 34 \n0 25 1 77 2 71 3 20 4 29 5 94 6 14 \n0 95 1 31 2 69 3 96 4 30 5 42 6 93 \n0 18 1 21 2 78 3 19 4 80 5 9 6 79 \n0 72 1 92 2 92 3 36 4 69 5 82 6 40 \n0 67 1 68 2 43 3 57 4 23 5 53 6 68 \n0 18 1 59 2 67 3 45 4 34 5 82 6 60 \n0 24 1 65 2 75 3 12 4 45 5 75 6 3 \n0 96 1 80 2 1 3 82 4 82 5 34 6 93 \n0 28 1 76 2 87 3 26 4 9 5 32 6 77 \n0 47 1 27 2 47 3 1 4 87 5 9 6 51 \n0 25 1 75 2 39 3 57 4 36 5 61 6 86 \n0 19 1 4 2 18 3 18 4 84 5 29 6 32 \n0 70 1 25 2 100 3 43 4 67 5 100 6 10 \n0 9 1 56 2 14 3 98 4 33 5 92 6 8 \n0 68 1 13 2 29 3 16 4 63 5 4 6 65 \n0 70 1 21 2 88 3 30 4 91 5 86 6 97 \n0 56 1 17 2 2 3 71 4 100 5 19 6 91 \n0 4 1 7 2 54 3 22 4 100 5 89 6 6 \n0 22 1 4 2 34 3 25 4 33 5 76 6 25 \n0 39 1 14 2 89 3 84 4 34 5 40 6 41 \n0 53 1 23 2 54 3 98 4 82 5 72 6 52 \n0 58 1 89 2 14 3 22 4 13 5 77 6 60 \n0 43 1 56 2 16 3 16 4 2 5 32 6 40 \n0 77 1 97 2 87 3 21 4 7 5 95 6 33 \n0 48 1 81 2 33 3 39 4 22 5 51 6 25 \n0 60 1 46 2 91 3 67 4 75 5 77 6 98 \n0 32 1 83 2 16 3 54 4 38 5 31 6 84 \n0 34 1 55 2 77 3 90 4 38 5 44 6 74 \n0 80 1 24 2 66 3 73 4 97 5 22 6 72 \n0 51 1 40 2 77 3 65 4 20 5 7 6 10 \n0 24 1 92 2 63 3 73 4 41 5 78 6 16 \n" }, { "path": "examples/user_fssp_gls/TrainingData/45.txt", "content": "50 6\n0 99 1 22 2 31 3 76 4 51 5 34 \n0 78 1 49 2 60 3 56 4 82 5 59 \n0 100 1 19 2 10 3 29 4 2 5 63 \n0 9 1 61 2 50 3 55 4 27 5 73 \n0 22 1 27 2 89 3 99 4 53 5 65 \n0 48 1 36 2 43 3 17 4 5 5 78 \n0 72 1 89 2 60 3 21 4 78 5 86 \n0 68 1 68 2 52 3 35 4 13 5 89 \n0 33 1 33 2 53 3 26 4 63 5 19 \n0 54 1 38 2 74 3 33 4 35 5 5 \n0 72 1 98 2 100 3 65 4 57 5 72 \n0 100 1 84 2 7 3 68 4 87 5 30 \n0 86 1 26 2 13 3 34 4 10 5 49 \n0 85 1 80 2 18 3 75 4 99 5 35 \n0 56 1 53 2 82 3 4 4 16 5 67 \n0 27 1 4 2 16 3 28 4 42 5 51 \n0 68 1 62 2 19 3 58 4 15 5 59 \n0 55 1 70 2 58 3 13 4 12 5 48 \n0 15 1 92 2 85 3 79 4 83 5 35 \n0 40 1 52 2 71 3 62 4 22 5 30 \n0 4 1 7 2 57 3 50 4 7 5 71 \n0 33 1 48 2 72 3 66 4 73 5 48 \n0 65 1 23 2 6 3 92 4 42 5 1 \n0 77 1 42 2 96 3 42 4 46 5 28 \n0 84 1 34 2 31 3 87 4 53 5 33 \n0 8 1 91 2 60 3 51 4 78 5 27 \n0 60 1 10 2 32 3 98 4 97 5 68 \n0 33 1 99 2 76 3 59 4 33 5 62 \n0 14 1 54 2 20 3 69 4 76 5 79 \n0 7 1 36 2 5 3 71 4 28 5 21 \n0 32 1 71 2 68 3 70 4 54 5 36 \n0 97 1 88 2 55 3 97 4 22 5 28 \n0 41 1 22 2 27 3 85 4 25 5 23 \n0 80 1 72 2 73 3 2 4 51 5 5 \n0 73 1 27 2 49 3 30 4 69 5 66 \n0 30 1 79 2 40 3 57 4 90 5 54 \n0 61 1 72 2 43 3 54 4 32 5 27 \n0 83 1 96 2 31 3 8 4 99 5 58 \n0 11 1 82 2 51 3 56 4 60 5 98 \n0 85 1 86 2 49 3 80 4 45 5 52 \n0 43 1 37 2 32 3 70 4 76 5 89 \n0 11 1 69 2 9 3 21 4 16 5 60 \n0 8 1 31 2 7 3 38 4 51 5 3 \n0 68 1 81 2 56 3 63 4 89 5 37 \n0 64 1 81 2 69 3 82 4 23 5 17 \n0 94 1 68 2 31 3 55 4 88 5 99 \n0 23 1 52 2 24 3 42 4 45 5 97 \n0 95 1 82 2 18 3 18 4 16 5 43 \n0 51 1 83 2 15 3 19 4 62 5 46 \n0 74 1 42 2 68 3 1 4 75 5 92 \n" }, { "path": "examples/user_fssp_gls/TrainingData/46.txt", "content": "50 17\n0 49 1 19 2 68 3 20 4 62 5 63 6 65 7 50 8 97 9 60 10 72 11 17 12 35 13 7 14 2 15 21 16 9 \n0 83 1 46 2 86 3 20 4 85 5 41 6 98 7 43 8 92 9 53 10 22 11 19 12 14 13 18 14 39 15 6 16 47 \n0 59 1 67 2 70 3 48 4 20 5 68 6 82 7 57 8 31 9 61 10 3 11 61 12 33 13 17 14 54 15 44 16 14 \n0 95 1 79 2 10 3 95 4 3 5 93 6 96 7 8 8 67 9 85 10 85 11 75 12 43 13 81 14 68 15 39 16 51 \n0 95 1 68 2 63 3 62 4 12 5 72 6 78 7 99 8 70 9 25 10 32 11 36 12 23 13 63 14 60 15 78 16 38 \n0 22 1 96 2 62 3 5 4 77 5 73 6 36 7 1 8 1 9 72 10 95 11 10 12 65 13 16 14 52 15 48 16 2 \n0 47 1 64 2 34 3 46 4 7 5 19 6 87 7 89 8 16 9 55 10 54 11 52 12 63 13 39 14 80 15 78 16 90 \n0 81 1 43 2 47 3 68 4 21 5 42 6 79 7 90 8 23 9 80 10 88 11 92 12 99 13 35 14 99 15 56 16 18 \n0 94 1 46 2 28 3 53 4 65 5 60 6 34 7 93 8 80 9 81 10 9 11 17 12 3 13 21 14 93 15 6 16 30 \n0 19 1 53 2 90 3 95 4 64 5 27 6 22 7 95 8 68 9 65 10 49 11 18 12 45 13 25 14 99 15 54 16 41 \n0 20 1 30 2 53 3 9 4 28 5 79 6 27 7 30 8 89 9 80 10 48 11 72 12 69 13 20 14 20 15 17 16 34 \n0 79 1 31 2 2 3 20 4 78 5 14 6 71 7 83 8 86 9 6 10 55 11 38 12 37 13 67 14 69 15 78 16 41 \n0 79 1 55 2 22 3 13 4 63 5 34 6 79 7 12 8 32 9 24 10 86 11 7 12 30 13 15 14 67 15 66 16 57 \n0 54 1 49 2 71 3 94 4 27 5 20 6 56 7 23 8 13 9 7 10 48 11 55 12 56 13 14 14 50 15 17 16 62 \n0 44 1 28 2 69 3 28 4 19 5 8 6 47 7 78 8 28 9 88 10 44 11 61 12 71 13 90 14 56 15 42 16 76 \n0 35 1 24 2 68 3 10 4 57 5 5 6 35 7 60 8 56 9 89 10 28 11 76 12 30 13 45 14 51 15 85 16 20 \n0 84 1 63 2 33 3 89 4 74 5 59 6 33 7 76 8 65 9 56 10 94 11 32 12 18 13 38 14 51 15 79 16 43 \n0 99 1 81 2 30 3 33 4 22 5 62 6 74 7 91 8 95 9 12 10 35 11 21 12 98 13 72 14 70 15 88 16 99 \n0 49 1 84 2 67 3 37 4 58 5 74 6 19 7 40 8 41 9 75 10 88 11 76 12 96 13 49 14 72 15 37 16 89 \n0 46 1 89 2 68 3 82 4 39 5 26 6 65 7 28 8 6 9 17 10 7 11 26 12 33 13 35 14 63 15 48 16 80 \n0 86 1 90 2 14 3 58 4 75 5 22 6 55 7 21 8 7 9 46 10 28 11 44 12 84 13 51 14 51 15 72 16 77 \n0 14 1 43 2 2 3 99 4 78 5 16 6 74 7 39 8 86 9 38 10 26 11 33 12 80 13 31 14 62 15 2 16 33 \n0 83 1 68 2 58 3 50 4 76 5 38 6 92 7 85 8 30 9 29 10 11 11 43 12 68 13 80 14 48 15 87 16 91 \n0 30 1 92 2 84 3 66 4 84 5 13 6 21 7 30 8 20 9 94 10 19 11 32 12 9 13 87 14 93 15 17 16 10 \n0 85 1 12 2 87 3 30 4 3 5 69 6 20 7 53 8 9 9 13 10 82 11 65 12 27 13 28 14 46 15 7 16 5 \n0 22 1 66 2 85 3 43 4 45 5 46 6 12 7 58 8 57 9 14 10 50 11 16 12 16 13 5 14 97 15 86 16 97 \n0 33 1 39 2 22 3 53 4 25 5 69 6 26 7 59 8 99 9 72 10 47 11 90 12 22 13 97 14 16 15 7 16 76 \n0 79 1 38 2 10 3 69 4 18 5 65 6 17 7 69 8 72 9 5 10 28 11 34 12 57 13 98 14 30 15 86 16 63 \n0 25 1 92 2 80 3 52 4 87 5 28 6 98 7 24 8 40 9 97 10 74 11 18 12 93 13 46 14 17 15 72 16 72 \n0 95 1 36 2 62 3 28 4 43 5 77 6 2 7 62 8 91 9 86 10 66 11 93 12 83 13 54 14 84 15 45 16 7 \n0 61 1 94 2 17 3 48 4 99 5 14 6 42 7 52 8 68 9 7 10 14 11 30 12 91 13 6 14 29 15 16 16 52 \n0 2 1 52 2 95 3 60 4 36 5 76 6 82 7 73 8 15 9 61 10 84 11 51 12 23 13 64 14 96 15 47 16 84 \n0 16 1 20 2 99 3 83 4 74 5 53 6 78 7 76 8 96 9 69 10 28 11 1 12 79 13 48 14 9 15 69 16 56 \n0 68 1 88 2 86 3 33 4 93 5 93 6 12 7 15 8 5 9 22 10 89 11 60 12 78 13 10 14 35 15 59 16 22 \n0 21 1 54 2 20 3 97 4 97 5 85 6 73 7 49 8 87 9 12 10 94 11 87 12 75 13 82 14 74 15 65 16 73 \n0 37 1 35 2 44 3 20 4 23 5 56 6 75 7 83 8 39 9 50 10 59 11 1 12 14 13 19 14 80 15 9 16 65 \n0 67 1 31 2 58 3 85 4 80 5 40 6 48 7 91 8 29 9 78 10 36 11 75 12 47 13 34 14 70 15 59 16 67 \n0 79 1 64 2 94 3 20 4 14 5 45 6 95 7 81 8 69 9 55 10 12 11 6 12 66 13 16 14 18 15 28 16 98 \n0 77 1 70 2 19 3 76 4 56 5 26 6 42 7 54 8 21 9 1 10 56 11 7 12 71 13 28 14 27 15 9 16 92 \n0 38 1 44 2 63 3 11 4 56 5 62 6 75 7 49 8 61 9 93 10 32 11 1 12 38 13 36 14 43 15 25 16 80 \n0 73 1 98 2 77 3 58 4 30 5 83 6 96 7 8 8 66 9 75 10 65 11 1 12 42 13 48 14 88 15 64 16 28 \n0 35 1 87 2 39 3 32 4 95 5 3 6 100 7 57 8 18 9 32 10 38 11 17 12 49 13 35 14 86 15 35 16 35 \n0 63 1 10 2 36 3 62 4 4 5 67 6 12 7 92 8 58 9 10 10 83 11 45 12 92 13 48 14 86 15 86 16 34 \n0 10 1 12 2 57 3 86 4 95 5 72 6 88 7 82 8 54 9 87 10 83 11 86 12 13 13 94 14 41 15 82 16 10 \n0 18 1 84 2 94 3 81 4 88 5 16 6 44 7 32 8 41 9 69 10 1 11 43 12 88 13 2 14 68 15 30 16 16 \n0 87 1 67 2 96 3 40 4 89 5 15 6 80 7 64 8 49 9 53 10 76 11 56 12 43 13 19 14 57 15 33 16 94 \n0 70 1 77 2 7 3 96 4 83 5 12 6 60 7 70 8 4 9 99 10 59 11 80 12 77 13 4 14 49 15 75 16 49 \n0 15 1 58 2 28 3 84 4 78 5 24 6 76 7 72 8 44 9 90 10 69 11 100 12 43 13 54 14 80 15 99 16 61 \n0 69 1 94 2 15 3 24 4 64 5 36 6 13 7 28 8 19 9 51 10 86 11 11 12 98 13 23 14 12 15 55 16 95 \n0 59 1 24 2 9 3 31 4 16 5 92 6 65 7 8 8 40 9 98 10 21 11 25 12 57 13 95 14 89 15 20 16 14 \n" }, { "path": "examples/user_fssp_gls/TrainingData/47.txt", "content": "50 15\n0 78 1 13 2 18 3 92 4 27 5 59 6 46 7 64 8 5 9 93 10 14 11 36 12 6 13 6 14 23 \n0 64 1 36 2 38 3 12 4 75 5 26 6 89 7 14 8 26 9 53 10 79 11 39 12 73 13 46 14 58 \n0 76 1 100 2 13 3 89 4 76 5 13 6 88 7 7 8 81 9 15 10 77 11 2 12 42 13 26 14 17 \n0 66 1 71 2 47 3 87 4 67 5 9 6 83 7 49 8 68 9 13 10 44 11 94 12 96 13 73 14 40 \n0 33 1 75 2 3 3 28 4 5 5 15 6 80 7 89 8 22 9 76 10 26 11 59 12 95 13 72 14 14 \n0 73 1 49 2 15 3 98 4 78 5 93 6 43 7 30 8 83 9 49 10 3 11 17 12 44 13 58 14 81 \n0 64 1 92 2 59 3 86 4 5 5 90 6 28 7 18 8 46 9 32 10 47 11 35 12 61 13 84 14 69 \n0 96 1 38 2 85 3 73 4 46 5 52 6 93 7 17 8 21 9 94 10 76 11 47 12 61 13 47 14 47 \n0 1 1 94 2 22 3 95 4 4 5 56 6 45 7 11 8 78 9 54 10 6 11 42 12 80 13 51 14 54 \n0 49 1 62 2 75 3 8 4 26 5 77 6 22 7 30 8 81 9 39 10 48 11 59 12 60 13 62 14 92 \n0 32 1 29 2 3 3 4 4 47 5 10 6 71 7 60 8 82 9 91 10 70 11 66 12 93 13 4 14 78 \n0 41 1 23 2 34 3 46 4 65 5 67 6 6 7 52 8 26 9 72 10 76 11 97 12 86 13 85 14 72 \n0 34 1 18 2 35 3 46 4 22 5 39 6 47 7 27 8 63 9 96 10 12 11 92 12 41 13 100 14 75 \n0 8 1 100 2 26 3 83 4 42 5 44 6 36 7 18 8 21 9 25 10 45 11 32 12 39 13 83 14 81 \n0 36 1 86 2 24 3 88 4 84 5 5 6 44 7 33 8 41 9 72 10 1 11 71 12 80 13 29 14 28 \n0 55 1 70 2 61 3 38 4 50 5 32 6 44 7 20 8 5 9 49 10 20 11 91 12 72 13 83 14 88 \n0 81 1 1 2 22 3 83 4 1 5 69 6 71 7 47 8 1 9 50 10 79 11 81 12 34 13 2 14 96 \n0 74 1 8 2 59 3 83 4 47 5 28 6 5 7 99 8 95 9 30 10 61 11 33 12 49 13 33 14 39 \n0 6 1 90 2 1 3 10 4 73 5 69 6 82 7 85 8 23 9 8 10 90 11 6 12 2 13 35 14 54 \n0 10 1 12 2 69 3 33 4 16 5 66 6 86 7 93 8 13 9 47 10 58 11 90 12 98 13 24 14 21 \n0 89 1 99 2 25 3 67 4 7 5 93 6 63 7 32 8 45 9 35 10 69 11 70 12 89 13 60 14 43 \n0 100 1 97 2 26 3 60 4 23 5 63 6 37 7 66 8 31 9 58 10 31 11 94 12 46 13 89 14 68 \n0 100 1 71 2 29 3 4 4 28 5 73 6 54 7 23 8 61 9 21 10 97 11 44 12 12 13 74 14 91 \n0 86 1 60 2 73 3 2 4 47 5 89 6 87 7 96 8 23 9 40 10 10 11 87 12 39 13 76 14 2 \n0 11 1 62 2 69 3 3 4 42 5 59 6 15 7 7 8 64 9 27 10 98 11 29 12 52 13 22 14 74 \n0 26 1 48 2 20 3 98 4 49 5 81 6 79 7 93 8 89 9 8 10 6 11 42 12 24 13 96 14 84 \n0 87 1 77 2 22 3 70 4 33 5 81 6 62 7 66 8 49 9 74 10 46 11 96 12 100 13 74 14 46 \n0 37 1 49 2 74 3 77 4 95 5 37 6 41 7 27 8 10 9 63 10 93 11 72 12 55 13 41 14 27 \n0 44 1 94 2 95 3 91 4 82 5 96 6 100 7 24 8 48 9 14 10 61 11 36 12 19 13 49 14 4 \n0 60 1 20 2 89 3 71 4 31 5 51 6 43 7 50 8 17 9 78 10 14 11 71 12 24 13 19 14 36 \n0 67 1 95 2 28 3 34 4 85 5 26 6 92 7 45 8 77 9 46 10 92 11 97 12 57 13 31 14 58 \n0 83 1 33 2 28 3 53 4 23 5 36 6 65 7 38 8 56 9 77 10 30 11 78 12 82 13 87 14 100 \n0 99 1 81 2 7 3 94 4 3 5 21 6 12 7 1 8 9 9 30 10 29 11 63 12 48 13 71 14 50 \n0 82 1 4 2 95 3 96 4 79 5 65 6 2 7 4 8 5 9 77 10 100 11 74 12 35 13 13 14 87 \n0 6 1 73 2 79 3 7 4 89 5 59 6 89 7 76 8 58 9 45 10 16 11 16 12 61 13 29 14 26 \n0 97 1 10 2 33 3 96 4 46 5 77 6 53 7 58 8 37 9 49 10 78 11 31 12 22 13 18 14 22 \n0 30 1 31 2 16 3 25 4 48 5 24 6 5 7 30 8 65 9 82 10 8 11 7 12 11 13 70 14 90 \n0 48 1 23 2 89 3 54 4 57 5 35 6 20 7 21 8 91 9 69 10 91 11 41 12 93 13 69 14 40 \n0 79 1 3 2 54 3 8 4 69 5 25 6 61 7 97 8 50 9 28 10 12 11 36 12 85 13 90 14 33 \n0 1 1 32 2 2 3 49 4 57 5 5 6 53 7 68 8 5 9 63 10 94 11 49 12 25 13 68 14 16 \n0 57 1 64 2 30 3 40 4 75 5 78 6 83 7 53 8 12 9 69 10 42 11 25 12 7 13 20 14 85 \n0 40 1 97 2 19 3 16 4 4 5 69 6 25 7 25 8 28 9 81 10 23 11 41 12 11 13 66 14 3 \n0 87 1 39 2 57 3 67 4 29 5 8 6 23 7 38 8 74 9 76 10 49 11 12 12 2 13 93 14 16 \n0 60 1 56 2 44 3 77 4 45 5 89 6 11 7 67 8 60 9 66 10 46 11 15 12 26 13 2 14 84 \n0 33 1 46 2 32 3 19 4 17 5 30 6 92 7 81 8 34 9 50 10 3 11 47 12 58 13 60 14 28 \n0 81 1 36 2 50 3 39 4 98 5 27 6 12 7 89 8 57 9 21 10 25 11 82 12 68 13 89 14 51 \n0 53 1 15 2 38 3 89 4 12 5 39 6 83 7 3 8 73 9 73 10 46 11 74 12 20 13 47 14 91 \n0 80 1 17 2 82 3 25 4 68 5 67 6 40 7 77 8 60 9 23 10 81 11 88 12 71 13 47 14 45 \n0 25 1 89 2 24 3 38 4 36 5 47 6 39 7 83 8 70 9 50 10 34 11 19 12 45 13 86 14 82 \n0 60 1 49 2 65 3 4 4 38 5 9 6 3 7 27 8 1 9 23 10 95 11 88 12 48 13 18 14 42 \n" }, { "path": "examples/user_fssp_gls/TrainingData/48.txt", "content": "50 5\n0 22 1 13 2 29 3 16 4 98 \n0 23 1 98 2 37 3 88 4 58 \n0 7 1 66 2 86 3 7 4 21 \n0 7 1 1 2 74 3 67 4 69 \n0 58 1 43 2 86 3 52 4 33 \n0 1 1 83 2 98 3 31 4 24 \n0 46 1 27 2 62 3 40 4 45 \n0 76 1 35 2 70 3 74 4 37 \n0 89 1 14 2 23 3 8 4 56 \n0 89 1 92 2 100 3 1 4 80 \n0 84 1 7 2 56 3 57 4 99 \n0 11 1 54 2 92 3 26 4 85 \n0 48 1 42 2 67 3 37 4 27 \n0 60 1 2 2 11 3 91 4 49 \n0 81 1 53 2 30 3 99 4 26 \n0 28 1 59 2 97 3 53 4 25 \n0 54 1 1 2 38 3 73 4 85 \n0 39 1 49 2 34 3 36 4 88 \n0 43 1 57 2 75 3 80 4 5 \n0 47 1 12 2 68 3 18 4 86 \n0 20 1 71 2 16 3 40 4 24 \n0 34 1 69 2 71 3 56 4 23 \n0 82 1 29 2 78 3 31 4 66 \n0 85 1 91 2 34 3 17 4 96 \n0 61 1 55 2 59 3 69 4 24 \n0 97 1 99 2 18 3 51 4 10 \n0 89 1 48 2 29 3 33 4 66 \n0 67 1 69 2 12 3 72 4 16 \n0 68 1 44 2 69 3 37 4 81 \n0 56 1 91 2 70 3 69 4 1 \n0 100 1 64 2 61 3 59 4 71 \n0 97 1 52 2 19 3 82 4 92 \n0 44 1 59 2 90 3 52 4 82 \n0 1 1 67 2 30 3 68 4 74 \n0 56 1 36 2 73 3 27 4 37 \n0 55 1 52 2 94 3 36 4 46 \n0 37 1 71 2 41 3 92 4 61 \n0 35 1 33 2 49 3 90 4 27 \n0 61 1 90 2 20 3 34 4 45 \n0 1 1 96 2 50 3 96 4 33 \n0 61 1 27 2 63 3 53 4 3 \n0 78 1 55 2 40 3 98 4 94 \n0 39 1 32 2 60 3 73 4 92 \n0 1 1 65 2 75 3 75 4 18 \n0 50 1 57 2 16 3 31 4 74 \n0 59 1 100 2 86 3 29 4 90 \n0 75 1 21 2 70 3 60 4 45 \n0 12 1 67 2 9 3 50 4 19 \n0 9 1 73 2 93 3 83 4 55 \n0 53 1 32 2 36 3 17 4 10 \n" }, { "path": "examples/user_fssp_gls/TrainingData/49.txt", "content": "50 11\n0 6 1 60 2 93 3 37 4 20 5 38 6 81 7 67 8 47 9 90 10 25 \n0 22 1 100 2 70 3 24 4 93 5 24 6 23 7 97 8 63 9 22 10 19 \n0 31 1 9 2 43 3 40 4 77 5 78 6 75 7 12 8 62 9 73 10 44 \n0 86 1 16 2 83 3 97 4 1 5 87 6 69 7 30 8 38 9 84 10 67 \n0 23 1 26 2 23 3 56 4 99 5 58 6 51 7 53 8 68 9 67 10 99 \n0 90 1 75 2 46 3 49 4 20 5 64 6 82 7 20 8 21 9 49 10 28 \n0 58 1 61 2 83 3 2 4 86 5 30 6 88 7 59 8 45 9 10 10 12 \n0 50 1 41 2 95 3 25 4 29 5 70 6 100 7 6 8 37 9 3 10 27 \n0 33 1 63 2 55 3 8 4 79 5 48 6 79 7 72 8 95 9 14 10 75 \n0 86 1 57 2 32 3 76 4 87 5 82 6 84 7 12 8 73 9 73 10 98 \n0 1 1 81 2 89 3 79 4 95 5 34 6 83 7 92 8 84 9 46 10 86 \n0 55 1 3 2 50 3 78 4 78 5 95 6 58 7 88 8 1 9 16 10 27 \n0 74 1 57 2 98 3 96 4 87 5 12 6 52 7 59 8 33 9 8 10 96 \n0 4 1 68 2 96 3 2 4 1 5 43 6 8 7 2 8 13 9 83 10 56 \n0 47 1 32 2 13 3 75 4 22 5 15 6 43 7 96 8 64 9 31 10 36 \n0 100 1 12 2 95 3 14 4 96 5 16 6 59 7 19 8 58 9 11 10 27 \n0 38 1 60 2 78 3 55 4 36 5 30 6 34 7 22 8 37 9 92 10 84 \n0 75 1 50 2 34 3 33 4 13 5 90 6 92 7 14 8 73 9 27 10 32 \n0 67 1 49 2 92 3 73 4 72 5 78 6 44 7 40 8 79 9 57 10 2 \n0 51 1 46 2 31 3 99 4 4 5 16 6 74 7 4 8 28 9 54 10 5 \n0 79 1 45 2 60 3 32 4 68 5 9 6 79 7 9 8 61 9 41 10 52 \n0 45 1 96 2 91 3 25 4 69 5 56 6 39 7 86 8 58 9 89 10 10 \n0 72 1 3 2 33 3 17 4 82 5 94 6 78 7 87 8 94 9 87 10 34 \n0 34 1 47 2 51 3 83 4 17 5 80 6 10 7 96 8 33 9 12 10 86 \n0 42 1 78 2 55 3 10 4 77 5 83 6 15 7 21 8 21 9 69 10 47 \n0 58 1 45 2 58 3 52 4 74 5 53 6 10 7 85 8 53 9 60 10 61 \n0 36 1 63 2 89 3 2 4 94 5 81 6 14 7 58 8 42 9 46 10 39 \n0 91 1 78 2 36 3 77 4 83 5 54 6 32 7 48 8 87 9 6 10 13 \n0 3 1 58 2 63 3 17 4 60 5 82 6 84 7 25 8 77 9 89 10 52 \n0 81 1 50 2 5 3 20 4 91 5 90 6 70 7 31 8 79 9 69 10 93 \n0 16 1 18 2 83 3 57 4 78 5 90 6 18 7 42 8 54 9 95 10 27 \n0 53 1 81 2 46 3 80 4 38 5 47 6 76 7 51 8 85 9 84 10 24 \n0 39 1 60 2 84 3 100 4 99 5 50 6 61 7 91 8 99 9 75 10 41 \n0 46 1 7 2 48 3 42 4 20 5 31 6 98 7 82 8 60 9 62 10 88 \n0 64 1 27 2 94 3 69 4 20 5 42 6 13 7 80 8 69 9 96 10 57 \n0 49 1 92 2 81 3 21 4 6 5 21 6 42 7 94 8 59 9 51 10 92 \n0 21 1 82 2 26 3 95 4 44 5 31 6 71 7 43 8 15 9 4 10 100 \n0 27 1 42 2 3 3 31 4 32 5 16 6 26 7 45 8 36 9 98 10 57 \n0 59 1 25 2 63 3 12 4 100 5 66 6 36 7 96 8 56 9 34 10 10 \n0 59 1 12 2 85 3 90 4 34 5 2 6 26 7 83 8 95 9 91 10 50 \n0 50 1 83 2 58 3 77 4 93 5 97 6 66 7 21 8 66 9 84 10 68 \n0 64 1 19 2 55 3 5 4 19 5 75 6 19 7 50 8 20 9 92 10 86 \n0 21 1 99 2 49 3 45 4 99 5 95 6 21 7 53 8 92 9 38 10 23 \n0 59 1 4 2 92 3 71 4 58 5 74 6 69 7 56 8 81 9 13 10 85 \n0 72 1 13 2 20 3 85 4 82 5 11 6 81 7 51 8 77 9 45 10 96 \n0 74 1 89 2 48 3 62 4 86 5 73 6 38 7 71 8 63 9 79 10 15 \n0 99 1 70 2 25 3 4 4 71 5 7 6 53 7 6 8 7 9 92 10 31 \n0 74 1 42 2 48 3 15 4 39 5 85 6 42 7 82 8 87 9 87 10 29 \n0 74 1 74 2 50 3 57 4 64 5 61 6 76 7 39 8 29 9 53 10 95 \n0 13 1 4 2 85 3 11 4 95 5 7 6 100 7 97 8 83 9 60 10 78 \n" }, { "path": "examples/user_fssp_gls/TrainingData/5.txt", "content": "50 6\n0 72 1 16 2 19 3 76 4 73 5 59 \n0 80 1 97 2 41 3 43 4 30 5 47 \n0 47 1 10 2 49 3 87 4 65 5 15 \n0 70 1 62 2 33 3 74 4 76 5 12 \n0 18 1 56 2 28 3 78 4 95 5 79 \n0 70 1 5 2 82 3 40 4 22 5 62 \n0 24 1 61 2 93 3 51 4 24 5 71 \n0 23 1 78 2 6 3 59 4 51 5 35 \n0 80 1 97 2 4 3 47 4 93 5 65 \n0 41 1 81 2 91 3 9 4 47 5 15 \n0 46 1 58 2 9 3 26 4 66 5 45 \n0 77 1 22 2 98 3 4 4 100 5 97 \n0 76 1 5 2 19 3 24 4 36 5 55 \n0 81 1 75 2 39 3 57 4 14 5 15 \n0 9 1 60 2 91 3 90 4 17 5 47 \n0 53 1 65 2 27 3 9 4 54 5 75 \n0 64 1 31 2 9 3 8 4 66 5 83 \n0 81 1 34 2 88 3 71 4 11 5 36 \n0 33 1 6 2 91 3 42 4 10 5 34 \n0 16 1 66 2 89 3 95 4 84 5 97 \n0 83 1 7 2 57 3 97 4 93 5 45 \n0 50 1 14 2 28 3 6 4 77 5 39 \n0 95 1 3 2 6 3 5 4 34 5 69 \n0 76 1 38 2 93 3 23 4 21 5 32 \n0 35 1 55 2 20 3 69 4 61 5 35 \n0 71 1 8 2 14 3 66 4 90 5 70 \n0 27 1 49 2 71 3 80 4 19 5 78 \n0 16 1 19 2 90 3 25 4 47 5 91 \n0 93 1 24 2 84 3 52 4 78 5 36 \n0 9 1 38 2 98 3 90 4 22 5 83 \n0 8 1 48 2 54 3 85 4 37 5 19 \n0 14 1 17 2 91 3 88 4 37 5 33 \n0 77 1 78 2 15 3 12 4 81 5 70 \n0 19 1 10 2 30 3 49 4 38 5 91 \n0 48 1 36 2 55 3 7 4 86 5 71 \n0 39 1 21 2 70 3 15 4 70 5 42 \n0 70 1 88 2 91 3 39 4 17 5 54 \n0 98 1 98 2 75 3 34 4 26 5 16 \n0 94 1 46 2 68 3 43 4 34 5 18 \n0 41 1 51 2 61 3 70 4 31 5 70 \n0 43 1 63 2 16 3 24 4 67 5 52 \n0 80 1 6 2 39 3 78 4 82 5 35 \n0 60 1 55 2 95 3 20 4 83 5 34 \n0 57 1 81 2 72 3 98 4 11 5 25 \n0 53 1 99 2 54 3 80 4 37 5 12 \n0 100 1 78 2 62 3 51 4 98 5 75 \n0 13 1 80 2 28 3 64 4 75 5 43 \n0 49 1 47 2 8 3 49 4 5 5 20 \n0 31 1 30 2 100 3 60 4 66 5 41 \n0 95 1 50 2 47 3 46 4 98 5 84 \n" }, { "path": "examples/user_fssp_gls/TrainingData/50.txt", "content": "50 2\n0 31 1 76 \n0 81 1 8 \n0 16 1 25 \n0 24 1 88 \n0 38 1 29 \n0 11 1 19 \n0 5 1 42 \n0 39 1 46 \n0 26 1 23 \n0 99 1 3 \n0 59 1 30 \n0 87 1 69 \n0 67 1 24 \n0 83 1 73 \n0 19 1 18 \n0 95 1 62 \n0 18 1 4 \n0 18 1 57 \n0 93 1 60 \n0 100 1 36 \n0 13 1 10 \n0 30 1 50 \n0 54 1 28 \n0 50 1 68 \n0 3 1 35 \n0 91 1 74 \n0 68 1 56 \n0 80 1 66 \n0 58 1 18 \n0 34 1 38 \n0 37 1 21 \n0 48 1 93 \n0 39 1 15 \n0 26 1 94 \n0 12 1 16 \n0 82 1 73 \n0 77 1 11 \n0 90 1 64 \n0 52 1 45 \n0 25 1 24 \n0 4 1 28 \n0 27 1 31 \n0 21 1 85 \n0 37 1 73 \n0 16 1 65 \n0 48 1 77 \n0 70 1 69 \n0 45 1 51 \n0 21 1 90 \n0 86 1 24 \n" }, { "path": "examples/user_fssp_gls/TrainingData/51.txt", "content": "50 11\n0 54 1 91 2 33 3 9 4 82 5 70 6 67 7 22 8 82 9 67 10 34 \n0 92 1 72 2 6 3 36 4 97 5 5 6 51 7 46 8 91 9 1 10 40 \n0 41 1 75 2 9 3 81 4 27 5 15 6 85 7 71 8 16 9 24 10 76 \n0 5 1 90 2 7 3 85 4 84 5 91 6 68 7 89 8 39 9 89 10 44 \n0 4 1 72 2 13 3 83 4 94 5 35 6 85 7 61 8 73 9 16 10 9 \n0 50 1 68 2 60 3 56 4 64 5 73 6 3 7 39 8 32 9 13 10 92 \n0 44 1 4 2 57 3 51 4 54 5 9 6 3 7 33 8 20 9 23 10 88 \n0 47 1 41 2 3 3 25 4 83 5 28 6 64 7 19 8 71 9 19 10 13 \n0 50 1 31 2 72 3 64 4 32 5 91 6 37 7 11 8 47 9 44 10 43 \n0 53 1 1 2 41 3 51 4 29 5 22 6 10 7 63 8 36 9 68 10 58 \n0 97 1 5 2 78 3 90 4 3 5 88 6 90 7 91 8 20 9 73 10 34 \n0 11 1 81 2 41 3 77 4 51 5 71 6 56 7 42 8 78 9 22 10 53 \n0 98 1 63 2 10 3 3 4 46 5 80 6 6 7 75 8 3 9 5 10 93 \n0 95 1 58 2 72 3 67 4 29 5 79 6 53 7 49 8 95 9 45 10 1 \n0 52 1 44 2 52 3 78 4 93 5 23 6 21 7 78 8 48 9 90 10 99 \n0 19 1 28 2 47 3 5 4 88 5 56 6 84 7 91 8 14 9 89 10 2 \n0 30 1 70 2 11 3 43 4 38 5 44 6 100 7 29 8 100 9 37 10 24 \n0 25 1 63 2 31 3 15 4 73 5 51 6 3 7 59 8 91 9 75 10 24 \n0 50 1 84 2 12 3 74 4 55 5 60 6 82 7 50 8 17 9 51 10 100 \n0 44 1 96 2 6 3 39 4 67 5 85 6 53 7 50 8 98 9 64 10 30 \n0 62 1 74 2 4 3 94 4 80 5 77 6 35 7 35 8 13 9 96 10 29 \n0 35 1 18 2 6 3 58 4 16 5 55 6 79 7 21 8 60 9 41 10 32 \n0 55 1 3 2 14 3 26 4 62 5 97 6 90 7 92 8 21 9 19 10 92 \n0 52 1 71 2 39 3 18 4 99 5 27 6 7 7 2 8 96 9 28 10 77 \n0 11 1 54 2 84 3 88 4 82 5 34 6 93 7 76 8 42 9 91 10 32 \n0 96 1 11 2 44 3 19 4 41 5 98 6 79 7 92 8 98 9 57 10 36 \n0 28 1 69 2 88 3 89 4 67 5 50 6 45 7 88 8 57 9 1 10 64 \n0 65 1 37 2 5 3 82 4 21 5 71 6 85 7 38 8 32 9 56 10 77 \n0 58 1 17 2 8 3 19 4 23 5 50 6 42 7 97 8 40 9 92 10 27 \n0 72 1 82 2 11 3 75 4 96 5 85 6 32 7 63 8 23 9 66 10 24 \n0 6 1 38 2 81 3 11 4 89 5 28 6 57 7 57 8 38 9 21 10 79 \n0 21 1 37 2 82 3 23 4 7 5 40 6 51 7 61 8 21 9 24 10 86 \n0 77 1 24 2 45 3 55 4 77 5 53 6 9 7 22 8 22 9 85 10 63 \n0 81 1 36 2 8 3 99 4 87 5 5 6 16 7 14 8 66 9 38 10 92 \n0 17 1 99 2 27 3 59 4 1 5 37 6 95 7 73 8 23 9 72 10 52 \n0 63 1 54 2 96 3 66 4 94 5 11 6 80 7 81 8 78 9 89 10 11 \n0 70 1 87 2 78 3 98 4 23 5 61 6 90 7 5 8 59 9 14 10 71 \n0 67 1 42 2 97 3 30 4 98 5 86 6 90 7 1 8 23 9 53 10 61 \n0 75 1 86 2 46 3 68 4 11 5 72 6 73 7 12 8 6 9 40 10 87 \n0 27 1 38 2 57 3 13 4 20 5 78 6 71 7 100 8 38 9 70 10 94 \n0 82 1 79 2 19 3 55 4 66 5 89 6 76 7 34 8 63 9 64 10 100 \n0 88 1 17 2 85 3 96 4 76 5 44 6 91 7 44 8 75 9 10 10 42 \n0 33 1 12 2 81 3 45 4 33 5 65 6 21 7 46 8 65 9 88 10 34 \n0 80 1 66 2 25 3 37 4 7 5 46 6 82 7 43 8 47 9 84 10 52 \n0 76 1 81 2 44 3 19 4 16 5 86 6 77 7 38 8 87 9 10 10 100 \n0 76 1 74 2 23 3 32 4 56 5 16 6 79 7 78 8 28 9 31 10 10 \n0 87 1 47 2 13 3 4 4 40 5 95 6 20 7 75 8 53 9 1 10 1 \n0 54 1 23 2 42 3 2 4 71 5 26 6 85 7 84 8 2 9 1 10 13 \n0 97 1 28 2 36 3 36 4 19 5 84 6 83 7 75 8 99 9 57 10 83 \n0 47 1 65 2 87 3 48 4 12 5 84 6 82 7 30 8 45 9 75 10 78 \n" }, { "path": "examples/user_fssp_gls/TrainingData/52.txt", "content": "50 11\n0 61 1 65 2 86 3 74 4 92 5 36 6 68 7 100 8 100 9 68 10 81 \n0 24 1 38 2 7 3 81 4 55 5 40 6 42 7 12 8 43 9 35 10 99 \n0 98 1 67 2 19 3 8 4 54 5 16 6 91 7 85 8 41 9 27 10 26 \n0 74 1 56 2 33 3 83 4 42 5 70 6 21 7 56 8 93 9 50 10 46 \n0 48 1 77 2 17 3 24 4 72 5 88 6 12 7 2 8 74 9 96 10 31 \n0 3 1 65 2 36 3 73 4 80 5 59 6 66 7 100 8 42 9 51 10 64 \n0 40 1 16 2 87 3 10 4 53 5 89 6 45 7 54 8 87 9 83 10 37 \n0 22 1 32 2 48 3 94 4 68 5 6 6 3 7 39 8 49 9 47 10 49 \n0 52 1 74 2 52 3 29 4 94 5 66 6 15 7 30 8 50 9 6 10 53 \n0 86 1 87 2 29 3 67 4 4 5 79 6 52 7 84 8 36 9 83 10 97 \n0 98 1 87 2 60 3 60 4 22 5 81 6 91 7 41 8 36 9 90 10 97 \n0 36 1 65 2 36 3 53 4 46 5 10 6 43 7 45 8 64 9 36 10 97 \n0 24 1 98 2 21 3 75 4 97 5 37 6 27 7 55 8 50 9 18 10 81 \n0 48 1 21 2 79 3 98 4 6 5 67 6 86 7 88 8 61 9 48 10 33 \n0 19 1 3 2 36 3 88 4 9 5 97 6 41 7 19 8 66 9 14 10 55 \n0 81 1 35 2 39 3 65 4 42 5 6 6 36 7 61 8 3 9 18 10 27 \n0 15 1 48 2 45 3 56 4 20 5 69 6 16 7 62 8 35 9 53 10 66 \n0 45 1 16 2 88 3 54 4 40 5 51 6 87 7 51 8 38 9 94 10 41 \n0 16 1 80 2 25 3 26 4 61 5 54 6 68 7 100 8 9 9 70 10 74 \n0 79 1 89 2 67 3 35 4 8 5 50 6 34 7 3 8 77 9 40 10 6 \n0 88 1 28 2 88 3 100 4 38 5 59 6 14 7 13 8 17 9 54 10 24 \n0 45 1 34 2 33 3 42 4 48 5 16 6 92 7 96 8 95 9 39 10 21 \n0 45 1 94 2 36 3 70 4 39 5 71 6 6 7 97 8 3 9 78 10 35 \n0 6 1 31 2 18 3 74 4 15 5 23 6 99 7 63 8 53 9 38 10 89 \n0 32 1 15 2 94 3 69 4 36 5 93 6 61 7 39 8 93 9 6 10 51 \n0 92 1 37 2 18 3 35 4 68 5 91 6 53 7 39 8 48 9 15 10 30 \n0 38 1 82 2 44 3 26 4 87 5 21 6 89 7 6 8 43 9 47 10 85 \n0 84 1 24 2 73 3 18 4 64 5 47 6 41 7 31 8 68 9 71 10 27 \n0 11 1 82 2 39 3 33 4 1 5 76 6 37 7 39 8 61 9 97 10 45 \n0 67 1 36 2 65 3 93 4 26 5 12 6 89 7 65 8 98 9 41 10 89 \n0 31 1 58 2 5 3 49 4 74 5 83 6 11 7 59 8 38 9 37 10 67 \n0 69 1 94 2 9 3 80 4 9 5 63 6 48 7 2 8 89 9 60 10 57 \n0 89 1 93 2 61 3 23 4 55 5 97 6 61 7 11 8 65 9 86 10 6 \n0 59 1 96 2 61 3 11 4 5 5 23 6 50 7 67 8 28 9 8 10 96 \n0 36 1 37 2 38 3 12 4 86 5 18 6 35 7 34 8 66 9 11 10 2 \n0 61 1 34 2 22 3 94 4 7 5 5 6 28 7 72 8 60 9 15 10 83 \n0 51 1 94 2 37 3 52 4 31 5 32 6 92 7 39 8 87 9 1 10 88 \n0 60 1 36 2 40 3 12 4 17 5 34 6 28 7 88 8 22 9 52 10 29 \n0 81 1 27 2 44 3 50 4 70 5 1 6 36 7 59 8 97 9 7 10 69 \n0 80 1 55 2 48 3 30 4 3 5 26 6 49 7 82 8 84 9 8 10 30 \n0 16 1 4 2 29 3 51 4 64 5 96 6 16 7 57 8 3 9 14 10 71 \n0 89 1 48 2 48 3 89 4 49 5 16 6 41 7 61 8 47 9 15 10 52 \n0 43 1 8 2 41 3 6 4 90 5 45 6 50 7 16 8 69 9 22 10 99 \n0 41 1 84 2 75 3 65 4 45 5 63 6 45 7 35 8 19 9 77 10 52 \n0 54 1 35 2 52 3 58 4 46 5 97 6 62 7 61 8 28 9 4 10 26 \n0 38 1 83 2 44 3 34 4 31 5 63 6 48 7 34 8 47 9 37 10 63 \n0 6 1 12 2 90 3 66 4 87 5 39 6 30 7 64 8 7 9 60 10 22 \n0 19 1 24 2 65 3 94 4 39 5 7 6 56 7 66 8 79 9 21 10 51 \n0 32 1 90 2 74 3 64 4 63 5 57 6 10 7 70 8 25 9 55 10 70 \n0 47 1 20 2 94 3 8 4 20 5 4 6 64 7 63 8 90 9 73 10 3 \n" }, { "path": "examples/user_fssp_gls/TrainingData/53.txt", "content": "50 6\n0 94 1 27 2 15 3 61 4 96 5 81 \n0 35 1 28 2 41 3 12 4 64 5 89 \n0 21 1 3 2 66 3 39 4 59 5 67 \n0 67 1 14 2 1 3 94 4 19 5 99 \n0 18 1 57 2 50 3 7 4 3 5 100 \n0 92 1 54 2 63 3 81 4 47 5 84 \n0 65 1 73 2 60 3 90 4 91 5 9 \n0 59 1 80 2 14 3 20 4 94 5 40 \n0 72 1 57 2 100 3 13 4 65 5 33 \n0 64 1 33 2 52 3 82 4 60 5 26 \n0 43 1 69 2 8 3 40 4 45 5 37 \n0 70 1 87 2 99 3 42 4 6 5 45 \n0 76 1 10 2 41 3 66 4 25 5 84 \n0 23 1 92 2 89 3 95 4 34 5 28 \n0 11 1 94 2 36 3 13 4 4 5 10 \n0 88 1 19 2 53 3 100 4 64 5 98 \n0 93 1 14 2 55 3 72 4 94 5 18 \n0 56 1 64 2 5 3 4 4 71 5 69 \n0 18 1 97 2 86 3 90 4 65 5 56 \n0 88 1 34 2 6 3 48 4 37 5 90 \n0 90 1 53 2 29 3 24 4 80 5 20 \n0 49 1 12 2 37 3 18 4 45 5 93 \n0 98 1 73 2 54 3 83 4 100 5 5 \n0 49 1 64 2 64 3 56 4 100 5 18 \n0 74 1 62 2 85 3 2 4 33 5 58 \n0 70 1 21 2 90 3 17 4 69 5 51 \n0 56 1 44 2 93 3 2 4 6 5 47 \n0 99 1 88 2 9 3 93 4 11 5 17 \n0 86 1 80 2 89 3 56 4 80 5 48 \n0 33 1 45 2 45 3 100 4 30 5 57 \n0 75 1 10 2 72 3 42 4 42 5 26 \n0 37 1 69 2 77 3 74 4 41 5 44 \n0 9 1 98 2 7 3 95 4 9 5 64 \n0 85 1 100 2 32 3 92 4 33 5 34 \n0 55 1 91 2 43 3 12 4 86 5 51 \n0 33 1 22 2 10 3 52 4 25 5 34 \n0 89 1 62 2 13 3 78 4 58 5 56 \n0 81 1 65 2 9 3 28 4 11 5 31 \n0 28 1 5 2 96 3 38 4 50 5 63 \n0 72 1 100 2 61 3 89 4 47 5 97 \n0 74 1 24 2 83 3 89 4 17 5 28 \n0 38 1 68 2 68 3 81 4 46 5 75 \n0 88 1 91 2 75 3 71 4 23 5 98 \n0 59 1 96 2 16 3 31 4 99 5 68 \n0 72 1 10 2 52 3 100 4 36 5 94 \n0 77 1 24 2 51 3 46 4 67 5 8 \n0 3 1 35 2 5 3 48 4 61 5 91 \n0 92 1 96 2 45 3 28 4 13 5 7 \n0 63 1 3 2 6 3 76 4 21 5 78 \n0 52 1 68 2 31 3 50 4 48 5 97 \n" }, { "path": "examples/user_fssp_gls/TrainingData/54.txt", "content": "50 6\n0 48 1 35 2 6 3 60 4 35 5 62 \n0 1 1 63 2 58 3 15 4 7 5 91 \n0 35 1 84 2 76 3 16 4 12 5 43 \n0 68 1 5 2 70 3 49 4 22 5 68 \n0 77 1 42 2 41 3 56 4 93 5 81 \n0 64 1 46 2 90 3 8 4 83 5 89 \n0 78 1 86 2 21 3 19 4 34 5 36 \n0 84 1 83 2 72 3 62 4 82 5 22 \n0 35 1 6 2 72 3 95 4 57 5 68 \n0 57 1 1 2 95 3 50 4 93 5 50 \n0 59 1 16 2 5 3 80 4 45 5 4 \n0 74 1 72 2 49 3 57 4 92 5 23 \n0 18 1 26 2 10 3 96 4 35 5 3 \n0 34 1 33 2 47 3 9 4 59 5 52 \n0 95 1 17 2 39 3 92 4 40 5 63 \n0 24 1 99 2 100 3 69 4 34 5 42 \n0 57 1 67 2 7 3 86 4 28 5 35 \n0 53 1 49 2 28 3 24 4 6 5 46 \n0 69 1 73 2 42 3 59 4 80 5 2 \n0 61 1 19 2 54 3 25 4 65 5 9 \n0 7 1 89 2 69 3 57 4 59 5 18 \n0 45 1 9 2 68 3 50 4 62 5 47 \n0 77 1 12 2 15 3 79 4 100 5 76 \n0 84 1 100 2 26 3 42 4 81 5 73 \n0 26 1 18 2 12 3 78 4 85 5 11 \n0 18 1 55 2 38 3 29 4 51 5 6 \n0 25 1 66 2 50 3 16 4 95 5 38 \n0 96 1 88 2 71 3 68 4 90 5 84 \n0 97 1 78 2 71 3 42 4 46 5 73 \n0 76 1 64 2 60 3 4 4 91 5 7 \n0 73 1 48 2 78 3 84 4 75 5 96 \n0 14 1 7 2 53 3 7 4 56 5 91 \n0 77 1 19 2 58 3 98 4 17 5 86 \n0 70 1 69 2 79 3 86 4 49 5 61 \n0 98 1 28 2 56 3 59 4 22 5 28 \n0 59 1 15 2 3 3 26 4 61 5 71 \n0 68 1 74 2 5 3 16 4 56 5 20 \n0 54 1 93 2 69 3 81 4 57 5 76 \n0 90 1 36 2 84 3 8 4 8 5 82 \n0 73 1 92 2 89 3 75 4 88 5 61 \n0 76 1 72 2 66 3 37 4 10 5 62 \n0 97 1 89 2 15 3 39 4 37 5 1 \n0 38 1 16 2 36 3 52 4 21 5 94 \n0 97 1 54 2 95 3 11 4 95 5 64 \n0 25 1 84 2 83 3 48 4 5 5 99 \n0 47 1 60 2 15 3 20 4 28 5 30 \n0 82 1 86 2 78 3 2 4 46 5 27 \n0 55 1 22 2 72 3 75 4 65 5 35 \n0 77 1 7 2 100 3 20 4 69 5 46 \n0 37 1 76 2 11 3 85 4 50 5 10 \n" }, { "path": "examples/user_fssp_gls/TrainingData/55.txt", "content": "50 10\n0 4 1 18 2 89 3 75 4 76 5 81 6 24 7 48 8 44 9 12 \n0 56 1 96 2 92 3 92 4 20 5 68 6 11 7 17 8 40 9 74 \n0 20 1 32 2 57 3 13 4 18 5 17 6 79 7 36 8 30 9 30 \n0 11 1 36 2 17 3 79 4 15 5 75 6 41 7 17 8 60 9 86 \n0 96 1 5 2 5 3 99 4 81 5 95 6 77 7 55 8 75 9 100 \n0 37 1 1 2 10 3 48 4 77 5 41 6 11 7 70 8 62 9 98 \n0 15 1 58 2 82 3 56 4 25 5 73 6 22 7 87 8 71 9 15 \n0 14 1 70 2 97 3 27 4 96 5 65 6 46 7 69 8 76 9 77 \n0 94 1 16 2 36 3 68 4 70 5 19 6 6 7 23 8 24 9 73 \n0 15 1 49 2 59 3 32 4 89 5 64 6 6 7 36 8 78 9 2 \n0 87 1 3 2 58 3 97 4 24 5 97 6 49 7 40 8 94 9 53 \n0 43 1 5 2 26 3 5 4 91 5 80 6 92 7 71 8 35 9 24 \n0 7 1 71 2 36 3 20 4 81 5 52 6 30 7 78 8 44 9 65 \n0 14 1 64 2 91 3 61 4 9 5 6 6 86 7 75 8 77 9 99 \n0 88 1 18 2 74 3 97 4 66 5 98 6 13 7 3 8 23 9 65 \n0 69 1 52 2 38 3 94 4 82 5 96 6 8 7 6 8 87 9 51 \n0 78 1 95 2 66 3 52 4 88 5 60 6 68 7 68 8 40 9 96 \n0 12 1 86 2 48 3 94 4 83 5 13 6 12 7 46 8 74 9 94 \n0 21 1 50 2 48 3 69 4 54 5 8 6 75 7 59 8 52 9 47 \n0 50 1 5 2 25 3 6 4 51 5 41 6 43 7 96 8 96 9 74 \n0 93 1 46 2 22 3 85 4 85 5 92 6 20 7 36 8 62 9 93 \n0 72 1 83 2 30 3 64 4 13 5 69 6 51 7 43 8 84 9 7 \n0 100 1 3 2 90 3 71 4 76 5 19 6 38 7 10 8 90 9 6 \n0 88 1 4 2 33 3 91 4 65 5 69 6 42 7 11 8 88 9 88 \n0 13 1 97 2 28 3 25 4 11 5 65 6 5 7 6 8 17 9 50 \n0 98 1 6 2 91 3 27 4 13 5 36 6 48 7 45 8 54 9 50 \n0 24 1 13 2 88 3 65 4 76 5 28 6 77 7 49 8 15 9 54 \n0 21 1 60 2 12 3 15 4 13 5 33 6 2 7 76 8 19 9 42 \n0 26 1 57 2 57 3 49 4 40 5 98 6 36 7 72 8 27 9 54 \n0 90 1 57 2 11 3 45 4 89 5 100 6 8 7 10 8 18 9 72 \n0 41 1 11 2 38 3 48 4 73 5 42 6 80 7 6 8 13 9 26 \n0 65 1 33 2 37 3 35 4 98 5 86 6 34 7 73 8 60 9 2 \n0 75 1 37 2 24 3 85 4 60 5 17 6 38 7 14 8 23 9 43 \n0 42 1 54 2 16 3 73 4 58 5 81 6 18 7 15 8 87 9 80 \n0 63 1 78 2 80 3 12 4 47 5 70 6 97 7 85 8 68 9 83 \n0 70 1 27 2 24 3 76 4 63 5 66 6 87 7 79 8 90 9 58 \n0 87 1 26 2 43 3 29 4 21 5 30 6 18 7 57 8 91 9 55 \n0 40 1 80 2 6 3 32 4 15 5 9 6 71 7 28 8 86 9 28 \n0 18 1 93 2 88 3 98 4 62 5 71 6 86 7 84 8 76 9 71 \n0 53 1 96 2 6 3 93 4 67 5 94 6 55 7 97 8 82 9 59 \n0 47 1 85 2 40 3 53 4 99 5 93 6 36 7 17 8 6 9 85 \n0 90 1 15 2 18 3 2 4 26 5 84 6 49 7 99 8 63 9 14 \n0 38 1 21 2 72 3 16 4 53 5 6 6 45 7 56 8 29 9 24 \n0 60 1 23 2 74 3 1 4 51 5 35 6 16 7 76 8 57 9 13 \n0 54 1 70 2 18 3 9 4 85 5 37 6 17 7 82 8 52 9 59 \n0 52 1 45 2 46 3 22 4 47 5 42 6 96 7 80 8 93 9 100 \n0 47 1 74 2 75 3 12 4 55 5 39 6 1 7 64 8 46 9 51 \n0 91 1 29 2 48 3 60 4 42 5 34 6 90 7 79 8 2 9 86 \n0 73 1 51 2 65 3 38 4 97 5 44 6 94 7 19 8 87 9 41 \n0 90 1 31 2 72 3 73 4 10 5 95 6 19 7 59 8 67 9 12 \n" }, { "path": "examples/user_fssp_gls/TrainingData/56.txt", "content": "50 18\n0 61 1 2 2 30 3 18 4 46 5 74 6 61 7 89 8 82 9 13 10 95 11 62 12 89 13 82 14 28 15 15 16 5 17 83 \n0 82 1 58 2 10 3 94 4 82 5 65 6 12 7 22 8 41 9 26 10 73 11 10 12 89 13 56 14 30 15 99 16 4 17 64 \n0 47 1 31 2 43 3 89 4 45 5 90 6 43 7 60 8 98 9 38 10 76 11 15 12 16 13 83 14 51 15 45 16 57 17 95 \n0 15 1 1 2 10 3 51 4 49 5 48 6 17 7 66 8 56 9 37 10 88 11 13 12 80 13 31 14 42 15 43 16 57 17 62 \n0 37 1 79 2 23 3 41 4 55 5 51 6 34 7 14 8 90 9 27 10 94 11 6 12 89 13 43 14 94 15 33 16 12 17 49 \n0 75 1 65 2 55 3 74 4 81 5 60 6 42 7 94 8 75 9 99 10 39 11 46 12 29 13 37 14 69 15 44 16 98 17 78 \n0 28 1 21 2 45 3 23 4 13 5 13 6 43 7 28 8 12 9 21 10 3 11 27 12 39 13 3 14 49 15 31 16 29 17 20 \n0 52 1 85 2 55 3 32 4 60 5 65 6 82 7 79 8 21 9 68 10 85 11 90 12 51 13 31 14 87 15 82 16 88 17 95 \n0 38 1 56 2 33 3 7 4 93 5 67 6 58 7 87 8 17 9 45 10 6 11 100 12 37 13 99 14 50 15 88 16 17 17 45 \n0 62 1 25 2 15 3 74 4 45 5 54 6 41 7 3 8 5 9 35 10 72 11 38 12 59 13 79 14 97 15 28 16 41 17 63 \n0 21 1 60 2 38 3 1 4 50 5 74 6 35 7 23 8 48 9 100 10 76 11 13 12 61 13 72 14 25 15 13 16 40 17 18 \n0 83 1 38 2 57 3 71 4 99 5 69 6 92 7 3 8 88 9 30 10 10 11 29 12 18 13 25 14 81 15 84 16 21 17 41 \n0 20 1 66 2 33 3 52 4 72 5 54 6 28 7 7 8 68 9 9 10 27 11 47 12 73 13 82 14 74 15 98 16 48 17 72 \n0 82 1 20 2 24 3 40 4 93 5 32 6 71 7 71 8 6 9 4 10 10 11 37 12 45 13 85 14 75 15 92 16 45 17 70 \n0 77 1 39 2 49 3 78 4 82 5 71 6 26 7 19 8 75 9 72 10 40 11 94 12 61 13 26 14 52 15 67 16 12 17 38 \n0 80 1 41 2 24 3 16 4 32 5 95 6 9 7 19 8 36 9 67 10 21 11 58 12 94 13 48 14 52 15 25 16 64 17 75 \n0 70 1 35 2 28 3 30 4 71 5 20 6 85 7 89 8 65 9 62 10 94 11 100 12 8 13 14 14 81 15 49 16 17 17 36 \n0 71 1 67 2 42 3 49 4 97 5 39 6 18 7 49 8 92 9 50 10 78 11 26 12 5 13 51 14 4 15 11 16 55 17 38 \n0 98 1 15 2 48 3 78 4 75 5 61 6 78 7 47 8 88 9 85 10 75 11 19 12 38 13 30 14 42 15 11 16 15 17 86 \n0 83 1 88 2 28 3 14 4 46 5 74 6 12 7 14 8 52 9 1 10 99 11 98 12 9 13 43 14 100 15 59 16 97 17 60 \n0 67 1 97 2 60 3 40 4 5 5 81 6 25 7 25 8 75 9 31 10 67 11 16 12 56 13 26 14 75 15 76 16 69 17 59 \n0 65 1 51 2 20 3 9 4 73 5 60 6 26 7 42 8 20 9 43 10 72 11 24 12 57 13 52 14 36 15 20 16 94 17 70 \n0 59 1 84 2 76 3 83 4 32 5 13 6 16 7 71 8 8 9 98 10 48 11 98 12 38 13 68 14 42 15 95 16 68 17 16 \n0 8 1 80 2 4 3 63 4 100 5 85 6 69 7 9 8 66 9 34 10 1 11 90 12 62 13 11 14 1 15 38 16 81 17 6 \n0 24 1 35 2 62 3 84 4 35 5 42 6 86 7 12 8 100 9 99 10 94 11 39 12 49 13 90 14 33 15 81 16 21 17 72 \n0 1 1 22 2 66 3 24 4 74 5 59 6 71 7 23 8 5 9 1 10 2 11 54 12 74 13 93 14 61 15 32 16 74 17 91 \n0 20 1 48 2 93 3 55 4 86 5 36 6 75 7 52 8 20 9 91 10 71 11 52 12 81 13 73 14 91 15 51 16 90 17 62 \n0 29 1 7 2 54 3 53 4 82 5 37 6 16 7 95 8 55 9 51 10 97 11 10 12 19 13 29 14 63 15 84 16 39 17 52 \n0 21 1 2 2 99 3 53 4 6 5 12 6 42 7 65 8 46 9 39 10 33 11 93 12 82 13 35 14 2 15 96 16 50 17 55 \n0 66 1 92 2 13 3 73 4 52 5 36 6 52 7 27 8 85 9 48 10 86 11 66 12 57 13 15 14 7 15 61 16 22 17 4 \n0 38 1 50 2 53 3 93 4 93 5 95 6 19 7 41 8 66 9 4 10 32 11 17 12 47 13 78 14 46 15 59 16 67 17 44 \n0 80 1 57 2 58 3 70 4 73 5 74 6 33 7 68 8 98 9 29 10 65 11 14 12 16 13 53 14 85 15 41 16 10 17 65 \n0 1 1 3 2 64 3 36 4 40 5 57 6 84 7 64 8 85 9 91 10 91 11 62 12 96 13 82 14 21 15 75 16 27 17 15 \n0 82 1 93 2 58 3 39 4 10 5 86 6 11 7 95 8 6 9 8 10 6 11 100 12 35 13 73 14 51 15 5 16 20 17 22 \n0 94 1 22 2 81 3 60 4 75 5 32 6 55 7 60 8 43 9 7 10 79 11 55 12 55 13 64 14 35 15 28 16 23 17 7 \n0 79 1 96 2 92 3 58 4 1 5 42 6 18 7 50 8 67 9 68 10 33 11 76 12 37 13 92 14 33 15 28 16 37 17 93 \n0 83 1 27 2 87 3 20 4 1 5 50 6 12 7 18 8 54 9 73 10 19 11 39 12 91 13 89 14 38 15 69 16 57 17 59 \n0 89 1 39 2 47 3 2 4 5 5 96 6 82 7 69 8 23 9 13 10 56 11 8 12 1 13 60 14 68 15 86 16 97 17 82 \n0 78 1 55 2 75 3 49 4 82 5 4 6 37 7 45 8 48 9 20 10 86 11 42 12 92 13 51 14 28 15 34 16 19 17 65 \n0 92 1 77 2 10 3 3 4 86 5 98 6 6 7 25 8 18 9 76 10 91 11 15 12 29 13 71 14 4 15 37 16 39 17 98 \n0 45 1 2 2 35 3 30 4 94 5 55 6 94 7 5 8 67 9 61 10 58 11 83 12 32 13 97 14 42 15 96 16 82 17 48 \n0 10 1 72 2 74 3 98 4 4 5 53 6 59 7 41 8 87 9 4 10 63 11 46 12 93 13 40 14 75 15 27 16 54 17 79 \n0 43 1 7 2 74 3 30 4 72 5 78 6 82 7 100 8 89 9 85 10 37 11 41 12 58 13 60 14 25 15 28 16 67 17 61 \n0 96 1 90 2 77 3 100 4 3 5 50 6 31 7 31 8 50 9 31 10 84 11 59 12 23 13 18 14 49 15 12 16 17 17 70 \n0 72 1 14 2 48 3 60 4 57 5 28 6 25 7 7 8 3 9 87 10 61 11 85 12 64 13 28 14 19 15 5 16 8 17 50 \n0 61 1 77 2 63 3 38 4 4 5 58 6 60 7 83 8 72 9 39 10 55 11 97 12 62 13 54 14 90 15 64 16 91 17 56 \n0 71 1 1 2 56 3 98 4 51 5 24 6 3 7 37 8 37 9 1 10 26 11 23 12 14 13 21 14 63 15 12 16 97 17 2 \n0 98 1 20 2 57 3 61 4 47 5 10 6 95 7 4 8 19 9 73 10 81 11 99 12 23 13 89 14 14 15 17 16 55 17 100 \n0 19 1 20 2 10 3 10 4 47 5 26 6 27 7 41 8 34 9 31 10 95 11 31 12 14 13 96 14 97 15 69 16 6 17 8 \n0 16 1 84 2 4 3 95 4 22 5 55 6 54 7 73 8 49 9 85 10 55 11 88 12 20 13 74 14 52 15 20 16 7 17 41 \n" }, { "path": "examples/user_fssp_gls/TrainingData/57.txt", "content": "50 4\n0 80 1 57 2 19 3 72 \n0 28 1 36 2 22 3 31 \n0 89 1 80 2 94 3 77 \n0 62 1 99 2 57 3 91 \n0 81 1 43 2 79 3 12 \n0 80 1 35 2 65 3 28 \n0 81 1 42 2 25 3 38 \n0 21 1 94 2 27 3 52 \n0 63 1 35 2 66 3 25 \n0 94 1 92 2 29 3 22 \n0 56 1 36 2 20 3 67 \n0 28 1 20 2 3 3 13 \n0 84 1 78 2 16 3 58 \n0 48 1 39 2 10 3 80 \n0 89 1 66 2 21 3 54 \n0 84 1 55 2 27 3 91 \n0 23 1 35 2 58 3 43 \n0 8 1 70 2 24 3 2 \n0 21 1 3 2 11 3 78 \n0 69 1 56 2 50 3 100 \n0 22 1 47 2 71 3 8 \n0 100 1 24 2 45 3 38 \n0 40 1 75 2 68 3 43 \n0 59 1 80 2 50 3 26 \n0 15 1 12 2 100 3 6 \n0 51 1 23 2 76 3 69 \n0 51 1 81 2 32 3 61 \n0 47 1 90 2 76 3 30 \n0 38 1 52 2 94 3 5 \n0 46 1 59 2 11 3 46 \n0 59 1 71 2 32 3 44 \n0 43 1 50 2 24 3 29 \n0 76 1 46 2 13 3 1 \n0 91 1 5 2 49 3 97 \n0 76 1 84 2 92 3 14 \n0 4 1 33 2 88 3 10 \n0 69 1 52 2 60 3 84 \n0 11 1 84 2 62 3 68 \n0 34 1 4 2 81 3 76 \n0 49 1 89 2 52 3 99 \n0 59 1 76 2 61 3 74 \n0 25 1 60 2 76 3 16 \n0 67 1 28 2 100 3 50 \n0 85 1 57 2 21 3 37 \n0 70 1 30 2 51 3 55 \n0 21 1 97 2 56 3 87 \n0 44 1 46 2 91 3 21 \n0 9 1 37 2 97 3 66 \n0 6 1 81 2 35 3 88 \n0 86 1 84 2 70 3 56 \n" }, { "path": "examples/user_fssp_gls/TrainingData/58.txt", "content": "50 18\n0 56 1 86 2 67 3 90 4 90 5 8 6 47 7 60 8 25 9 24 10 29 11 74 12 75 13 85 14 24 15 70 16 5 17 61 \n0 12 1 84 2 18 3 57 4 94 5 80 6 71 7 35 8 18 9 39 10 52 11 84 12 30 13 7 14 78 15 75 16 44 17 25 \n0 27 1 38 2 3 3 40 4 19 5 68 6 39 7 63 8 69 9 85 10 13 11 79 12 46 13 78 14 5 15 39 16 68 17 85 \n0 55 1 22 2 5 3 62 4 28 5 85 6 16 7 94 8 98 9 30 10 100 11 22 12 14 13 94 14 9 15 51 16 91 17 29 \n0 15 1 6 2 48 3 47 4 36 5 89 6 39 7 86 8 23 9 88 10 61 11 93 12 7 13 24 14 98 15 30 16 12 17 86 \n0 25 1 90 2 1 3 69 4 70 5 45 6 85 7 23 8 2 9 92 10 49 11 35 12 79 13 47 14 58 15 67 16 63 17 88 \n0 1 1 16 2 5 3 11 4 17 5 66 6 19 7 5 8 78 9 29 10 23 11 31 12 69 13 11 14 61 15 42 16 50 17 78 \n0 11 1 61 2 83 3 84 4 31 5 16 6 87 7 12 8 75 9 63 10 16 11 44 12 71 13 34 14 51 15 45 16 50 17 91 \n0 65 1 36 2 54 3 34 4 7 5 94 6 57 7 2 8 63 9 86 10 68 11 3 12 44 13 14 14 21 15 7 16 63 17 46 \n0 41 1 58 2 25 3 76 4 17 5 91 6 47 7 59 8 7 9 90 10 60 11 79 12 28 13 77 14 68 15 3 16 73 17 38 \n0 17 1 79 2 91 3 37 4 67 5 36 6 14 7 84 8 91 9 29 10 3 11 98 12 59 13 6 14 68 15 97 16 10 17 28 \n0 51 1 94 2 19 3 15 4 67 5 63 6 22 7 92 8 96 9 44 10 15 11 55 12 42 13 57 14 64 15 31 16 54 17 30 \n0 24 1 58 2 90 3 44 4 93 5 21 6 95 7 29 8 55 9 49 10 54 11 12 12 90 13 50 14 51 15 82 16 52 17 91 \n0 53 1 16 2 9 3 85 4 87 5 56 6 66 7 5 8 100 9 80 10 77 11 29 12 33 13 51 14 97 15 2 16 55 17 12 \n0 26 1 92 2 7 3 20 4 27 5 21 6 43 7 7 8 89 9 92 10 65 11 70 12 48 13 81 14 74 15 86 16 68 17 13 \n0 78 1 70 2 94 3 14 4 83 5 71 6 34 7 19 8 9 9 55 10 50 11 43 12 65 13 35 14 5 15 97 16 8 17 7 \n0 72 1 63 2 42 3 97 4 22 5 80 6 3 7 18 8 94 9 70 10 73 11 84 12 37 13 9 14 78 15 24 16 13 17 31 \n0 72 1 60 2 38 3 91 4 69 5 13 6 27 7 10 8 56 9 88 10 29 11 3 12 74 13 21 14 36 15 46 16 50 17 13 \n0 59 1 100 2 50 3 93 4 65 5 14 6 62 7 10 8 63 9 31 10 90 11 1 12 49 13 99 14 14 15 29 16 11 17 72 \n0 88 1 46 2 21 3 85 4 65 5 28 6 55 7 42 8 50 9 85 10 47 11 39 12 5 13 20 14 72 15 55 16 10 17 16 \n0 64 1 74 2 81 3 50 4 10 5 10 6 94 7 69 8 10 9 3 10 58 11 89 12 59 13 72 14 10 15 65 16 90 17 55 \n0 29 1 29 2 27 3 45 4 24 5 49 6 78 7 37 8 28 9 53 10 42 11 80 12 5 13 100 14 37 15 52 16 20 17 89 \n0 59 1 42 2 96 3 70 4 44 5 29 6 24 7 16 8 83 9 51 10 34 11 15 12 42 13 93 14 10 15 68 16 99 17 38 \n0 38 1 38 2 64 3 37 4 65 5 85 6 59 7 32 8 67 9 73 10 38 11 86 12 4 13 57 14 20 15 37 16 23 17 72 \n0 49 1 60 2 80 3 6 4 77 5 49 6 98 7 93 8 42 9 47 10 45 11 93 12 40 13 57 14 45 15 83 16 17 17 50 \n0 74 1 7 2 16 3 54 4 17 5 8 6 63 7 36 8 64 9 34 10 70 11 78 12 48 13 70 14 6 15 41 16 75 17 85 \n0 63 1 87 2 55 3 91 4 98 5 72 6 11 7 47 8 54 9 96 10 91 11 89 12 5 13 65 14 51 15 92 16 18 17 61 \n0 55 1 62 2 57 3 41 4 93 5 84 6 93 7 92 8 81 9 43 10 79 11 2 12 18 13 52 14 77 15 55 16 79 17 55 \n0 91 1 86 2 71 3 3 4 31 5 74 6 86 7 73 8 19 9 43 10 34 11 97 12 15 13 12 14 25 15 37 16 43 17 28 \n0 75 1 31 2 27 3 13 4 40 5 71 6 67 7 26 8 22 9 11 10 58 11 73 12 52 13 1 14 5 15 6 16 42 17 44 \n0 1 1 77 2 77 3 47 4 10 5 41 6 59 7 70 8 18 9 63 10 40 11 96 12 78 13 54 14 29 15 65 16 68 17 63 \n0 84 1 4 2 13 3 70 4 1 5 41 6 86 7 18 8 46 9 75 10 98 11 38 12 63 13 52 14 72 15 47 16 20 17 94 \n0 6 1 26 2 16 3 17 4 80 5 69 6 74 7 27 8 51 9 5 10 89 11 88 12 76 13 45 14 33 15 17 16 100 17 59 \n0 25 1 93 2 55 3 37 4 58 5 79 6 88 7 64 8 77 9 32 10 26 11 68 12 1 13 22 14 90 15 62 16 38 17 83 \n0 76 1 38 2 51 3 64 4 49 5 21 6 14 7 66 8 83 9 56 10 42 11 75 12 31 13 88 14 81 15 28 16 18 17 72 \n0 25 1 25 2 78 3 48 4 92 5 17 6 54 7 59 8 12 9 63 10 12 11 95 12 92 13 50 14 28 15 8 16 27 17 20 \n0 62 1 4 2 84 3 29 4 2 5 47 6 97 7 83 8 91 9 85 10 87 11 34 12 48 13 47 14 82 15 29 16 80 17 66 \n0 32 1 68 2 58 3 61 4 19 5 40 6 46 7 34 8 95 9 99 10 19 11 37 12 92 13 74 14 26 15 4 16 94 17 79 \n0 35 1 22 2 38 3 21 4 89 5 71 6 84 7 80 8 6 9 87 10 15 11 23 12 75 13 7 14 56 15 19 16 4 17 23 \n0 73 1 28 2 31 3 62 4 62 5 84 6 21 7 26 8 87 9 72 10 45 11 87 12 57 13 42 14 55 15 7 16 7 17 84 \n0 16 1 83 2 9 3 87 4 51 5 68 6 48 7 73 8 36 9 14 10 82 11 79 12 82 13 19 14 9 15 87 16 78 17 31 \n0 47 1 36 2 20 3 62 4 41 5 10 6 49 7 94 8 53 9 87 10 66 11 30 12 52 13 59 14 1 15 29 16 42 17 95 \n0 47 1 46 2 92 3 98 4 93 5 17 6 73 7 43 8 73 9 79 10 53 11 45 12 78 13 62 14 84 15 55 16 70 17 3 \n0 45 1 45 2 44 3 95 4 86 5 74 6 98 7 44 8 36 9 54 10 69 11 32 12 25 13 53 14 1 15 38 16 77 17 97 \n0 11 1 95 2 2 3 39 4 41 5 71 6 35 7 50 8 38 9 28 10 25 11 32 12 63 13 67 14 55 15 37 16 92 17 44 \n0 66 1 45 2 77 3 27 4 27 5 12 6 27 7 5 8 16 9 18 10 77 11 27 12 53 13 81 14 33 15 98 16 93 17 2 \n0 39 1 76 2 68 3 43 4 34 5 61 6 96 7 91 8 74 9 42 10 45 11 81 12 81 13 71 14 100 15 100 16 76 17 70 \n0 47 1 75 2 68 3 82 4 65 5 88 6 79 7 26 8 68 9 5 10 4 11 57 12 24 13 19 14 65 15 40 16 17 17 87 \n0 25 1 3 2 43 3 44 4 35 5 12 6 82 7 7 8 24 9 29 10 95 11 3 12 24 13 24 14 74 15 39 16 41 17 16 \n0 72 1 87 2 11 3 71 4 73 5 21 6 3 7 5 8 32 9 67 10 11 11 68 12 46 13 80 14 83 15 42 16 37 17 10 \n" }, { "path": "examples/user_fssp_gls/TrainingData/59.txt", "content": "50 15\n0 41 1 85 2 64 3 76 4 3 5 18 6 18 7 98 8 47 9 83 10 56 11 32 12 68 13 57 14 51 \n0 84 1 97 2 52 3 56 4 17 5 27 6 19 7 45 8 100 9 98 10 48 11 36 12 98 13 30 14 91 \n0 34 1 48 2 87 3 15 4 30 5 8 6 64 7 15 8 62 9 71 10 3 11 61 12 64 13 70 14 14 \n0 72 1 40 2 85 3 94 4 16 5 95 6 26 7 38 8 69 9 71 10 23 11 68 12 18 13 85 14 94 \n0 43 1 25 2 67 3 52 4 21 5 13 6 56 7 39 8 60 9 66 10 25 11 38 12 18 13 2 14 56 \n0 63 1 5 2 90 3 51 4 55 5 23 6 10 7 32 8 72 9 53 10 71 11 16 12 43 13 39 14 1 \n0 54 1 91 2 28 3 22 4 69 5 1 6 57 7 54 8 41 9 20 10 24 11 74 12 33 13 64 14 22 \n0 65 1 76 2 75 3 51 4 34 5 66 6 8 7 60 8 94 9 98 10 11 11 12 12 67 13 5 14 88 \n0 86 1 12 2 91 3 2 4 91 5 30 6 84 7 47 8 18 9 55 10 9 11 22 12 58 13 45 14 46 \n0 53 1 78 2 88 3 100 4 66 5 35 6 44 7 65 8 62 9 65 10 32 11 75 12 67 13 82 14 26 \n0 93 1 71 2 80 3 89 4 55 5 67 6 92 7 7 8 63 9 45 10 15 11 58 12 78 13 90 14 18 \n0 18 1 98 2 34 3 75 4 87 5 54 6 4 7 100 8 14 9 81 10 28 11 61 12 99 13 90 14 87 \n0 24 1 90 2 92 3 18 4 6 5 56 6 89 7 96 8 90 9 27 10 99 11 72 12 10 13 82 14 48 \n0 23 1 76 2 60 3 78 4 4 5 43 6 45 7 1 8 35 9 15 10 50 11 98 12 18 13 32 14 47 \n0 76 1 57 2 48 3 2 4 31 5 58 6 5 7 54 8 60 9 14 10 2 11 32 12 65 13 70 14 100 \n0 73 1 6 2 22 3 47 4 84 5 48 6 2 7 19 8 87 9 52 10 97 11 51 12 20 13 87 14 3 \n0 62 1 66 2 31 3 67 4 64 5 77 6 79 7 33 8 44 9 45 10 50 11 80 12 8 13 30 14 92 \n0 40 1 73 2 63 3 35 4 77 5 4 6 41 7 92 8 6 9 82 10 13 11 78 12 64 13 12 14 51 \n0 58 1 7 2 51 3 31 4 25 5 67 6 80 7 76 8 55 9 89 10 48 11 84 12 87 13 92 14 45 \n0 72 1 59 2 4 3 28 4 39 5 52 6 69 7 54 8 66 9 15 10 77 11 91 12 97 13 66 14 13 \n0 2 1 99 2 15 3 91 4 31 5 21 6 14 7 58 8 70 9 11 10 87 11 40 12 3 13 39 14 79 \n0 71 1 100 2 68 3 39 4 58 5 30 6 59 7 81 8 80 9 23 10 20 11 70 12 89 13 98 14 20 \n0 70 1 84 2 60 3 58 4 91 5 65 6 80 7 10 8 77 9 2 10 14 11 98 12 37 13 78 14 14 \n0 11 1 87 2 64 3 32 4 66 5 40 6 22 7 43 8 78 9 41 10 1 11 19 12 97 13 5 14 90 \n0 83 1 20 2 46 3 5 4 56 5 42 6 77 7 99 8 13 9 54 10 64 11 97 12 96 13 98 14 48 \n0 3 1 12 2 3 3 2 4 30 5 34 6 57 7 92 8 85 9 94 10 17 11 59 12 94 13 57 14 39 \n0 22 1 19 2 78 3 77 4 16 5 68 6 17 7 18 8 12 9 31 10 44 11 81 12 13 13 77 14 52 \n0 39 1 53 2 47 3 21 4 20 5 44 6 67 7 55 8 83 9 29 10 14 11 2 12 52 13 86 14 32 \n0 36 1 12 2 55 3 21 4 46 5 80 6 69 7 33 8 37 9 78 10 27 11 86 12 33 13 75 14 61 \n0 94 1 81 2 100 3 4 4 94 5 13 6 31 7 73 8 75 9 94 10 64 11 99 12 33 13 76 14 38 \n0 39 1 93 2 6 3 37 4 37 5 5 6 54 7 70 8 2 9 55 10 40 11 14 12 34 13 91 14 70 \n0 63 1 56 2 82 3 73 4 100 5 50 6 80 7 60 8 44 9 11 10 46 11 93 12 27 13 99 14 4 \n0 36 1 99 2 7 3 13 4 29 5 75 6 63 7 16 8 72 9 80 10 70 11 73 12 85 13 15 14 93 \n0 48 1 15 2 99 3 93 4 43 5 70 6 6 7 64 8 40 9 92 10 40 11 85 12 95 13 11 14 70 \n0 77 1 62 2 78 3 62 4 91 5 9 6 86 7 74 8 6 9 55 10 13 11 94 12 59 13 28 14 30 \n0 85 1 68 2 99 3 78 4 10 5 97 6 47 7 14 8 14 9 48 10 56 11 42 12 10 13 52 14 45 \n0 32 1 87 2 23 3 15 4 86 5 16 6 51 7 50 8 9 9 99 10 24 11 47 12 16 13 80 14 74 \n0 100 1 79 2 39 3 62 4 78 5 54 6 45 7 97 8 95 9 25 10 15 11 29 12 59 13 29 14 56 \n0 72 1 53 2 15 3 5 4 48 5 76 6 17 7 14 8 55 9 73 10 17 11 18 12 55 13 8 14 27 \n0 29 1 92 2 70 3 40 4 18 5 91 6 9 7 82 8 28 9 68 10 92 11 8 12 75 13 94 14 69 \n0 31 1 17 2 37 3 98 4 90 5 34 6 35 7 29 8 27 9 12 10 9 11 30 12 74 13 27 14 76 \n0 93 1 73 2 69 3 50 4 75 5 49 6 45 7 63 8 68 9 32 10 3 11 25 12 14 13 38 14 62 \n0 31 1 53 2 59 3 67 4 53 5 85 6 6 7 57 8 72 9 76 10 36 11 74 12 57 13 20 14 82 \n0 60 1 18 2 45 3 94 4 15 5 22 6 16 7 12 8 20 9 40 10 31 11 53 12 44 13 45 14 24 \n0 95 1 9 2 82 3 60 4 98 5 100 6 11 7 67 8 80 9 60 10 44 11 50 12 62 13 5 14 92 \n0 79 1 65 2 23 3 31 4 40 5 95 6 12 7 23 8 63 9 58 10 15 11 25 12 79 13 72 14 52 \n0 35 1 8 2 44 3 13 4 10 5 89 6 1 7 34 8 35 9 82 10 3 11 32 12 19 13 47 14 73 \n0 92 1 7 2 96 3 90 4 31 5 93 6 9 7 33 8 55 9 11 10 10 11 40 12 76 13 44 14 93 \n0 28 1 21 2 14 3 73 4 3 5 49 6 31 7 76 8 67 9 23 10 81 11 61 12 50 13 78 14 31 \n0 60 1 19 2 8 3 42 4 15 5 22 6 80 7 1 8 14 9 89 10 40 11 41 12 99 13 50 14 68 \n" }, { "path": "examples/user_fssp_gls/TrainingData/6.txt", "content": "50 5\n0 21 1 70 2 87 3 40 4 65 \n0 94 1 81 2 44 3 40 4 29 \n0 80 1 80 2 16 3 18 4 41 \n0 56 1 94 2 100 3 82 4 30 \n0 16 1 99 2 77 3 50 4 52 \n0 7 1 57 2 61 3 46 4 22 \n0 83 1 52 2 72 3 42 4 25 \n0 76 1 85 2 29 3 59 4 86 \n0 76 1 7 2 58 3 58 4 70 \n0 63 1 28 2 32 3 95 4 87 \n0 4 1 27 2 10 3 99 4 82 \n0 10 1 79 2 10 3 92 4 62 \n0 72 1 5 2 4 3 51 4 2 \n0 69 1 65 2 1 3 100 4 46 \n0 66 1 16 2 8 3 77 4 40 \n0 51 1 56 2 7 3 61 4 3 \n0 13 1 64 2 31 3 75 4 65 \n0 38 1 7 2 45 3 71 4 66 \n0 31 1 80 2 27 3 96 4 57 \n0 32 1 70 2 61 3 15 4 65 \n0 36 1 40 2 1 3 29 4 82 \n0 67 1 85 2 45 3 83 4 70 \n0 89 1 2 2 45 3 46 4 81 \n0 21 1 25 2 62 3 71 4 16 \n0 92 1 34 2 66 3 55 4 72 \n0 60 1 95 2 25 3 39 4 73 \n0 45 1 83 2 65 3 68 4 61 \n0 14 1 20 2 65 3 70 4 84 \n0 91 1 94 2 63 3 2 4 91 \n0 19 1 28 2 75 3 28 4 42 \n0 76 1 88 2 8 3 84 4 4 \n0 32 1 88 2 74 3 49 4 78 \n0 38 1 72 2 60 3 39 4 91 \n0 57 1 95 2 76 3 24 4 79 \n0 85 1 70 2 85 3 100 4 64 \n0 76 1 87 2 66 3 92 4 96 \n0 69 1 12 2 77 3 79 4 38 \n0 31 1 52 2 64 3 61 4 69 \n0 46 1 2 2 48 3 60 4 38 \n0 37 1 16 2 13 3 44 4 42 \n0 29 1 3 2 61 3 31 4 5 \n0 38 1 7 2 84 3 96 4 55 \n0 95 1 18 2 97 3 19 4 100 \n0 59 1 71 2 40 3 34 4 41 \n0 60 1 64 2 10 3 63 4 89 \n0 95 1 61 2 49 3 12 4 50 \n0 53 1 32 2 86 3 79 4 62 \n0 100 1 64 2 41 3 52 4 45 \n0 33 1 36 2 30 3 54 4 11 \n0 10 1 39 2 29 3 65 4 82 \n" }, { "path": "examples/user_fssp_gls/TrainingData/60.txt", "content": "50 9\n0 66 1 86 2 1 3 83 4 100 5 54 6 16 7 83 8 61 \n0 87 1 92 2 11 3 88 4 77 5 67 6 46 7 4 8 44 \n0 23 1 42 2 45 3 82 4 18 5 26 6 58 7 66 8 22 \n0 19 1 87 2 70 3 63 4 9 5 84 6 15 7 55 8 21 \n0 8 1 77 2 75 3 72 4 63 5 99 6 1 7 93 8 1 \n0 36 1 2 2 36 3 82 4 98 5 2 6 4 7 1 8 73 \n0 79 1 5 2 47 3 17 4 32 5 73 6 5 7 9 8 1 \n0 65 1 53 2 20 3 91 4 89 5 23 6 69 7 24 8 80 \n0 51 1 24 2 10 3 15 4 4 5 32 6 14 7 29 8 89 \n0 23 1 46 2 30 3 2 4 76 5 48 6 10 7 26 8 94 \n0 73 1 84 2 34 3 17 4 14 5 18 6 58 7 94 8 26 \n0 6 1 92 2 12 3 55 4 12 5 18 6 19 7 4 8 99 \n0 62 1 94 2 32 3 20 4 32 5 4 6 27 7 13 8 94 \n0 25 1 13 2 94 3 94 4 93 5 57 6 91 7 93 8 26 \n0 93 1 34 2 64 3 89 4 76 5 62 6 45 7 97 8 9 \n0 93 1 83 2 9 3 16 4 69 5 18 6 59 7 42 8 12 \n0 13 1 72 2 47 3 50 4 45 5 62 6 86 7 11 8 87 \n0 95 1 10 2 63 3 29 4 31 5 47 6 69 7 58 8 94 \n0 40 1 23 2 89 3 87 4 39 5 91 6 42 7 1 8 20 \n0 94 1 17 2 65 3 10 4 51 5 61 6 15 7 29 8 71 \n0 10 1 80 2 3 3 68 4 15 5 64 6 80 7 96 8 8 \n0 34 1 67 2 65 3 69 4 89 5 30 6 58 7 74 8 11 \n0 94 1 80 2 55 3 59 4 41 5 59 6 81 7 24 8 18 \n0 58 1 25 2 97 3 29 4 77 5 26 6 34 7 64 8 73 \n0 28 1 36 2 67 3 42 4 10 5 97 6 67 7 45 8 80 \n0 14 1 51 2 26 3 41 4 94 5 86 6 77 7 4 8 3 \n0 88 1 58 2 32 3 26 4 10 5 85 6 40 7 84 8 56 \n0 74 1 27 2 90 3 22 4 44 5 23 6 10 7 78 8 73 \n0 61 1 37 2 90 3 90 4 91 5 69 6 1 7 41 8 20 \n0 96 1 73 2 72 3 47 4 20 5 7 6 44 7 11 8 16 \n0 21 1 79 2 65 3 1 4 61 5 89 6 64 7 67 8 62 \n0 37 1 96 2 26 3 89 4 19 5 59 6 2 7 77 8 97 \n0 15 1 8 2 19 3 76 4 39 5 26 6 39 7 69 8 87 \n0 72 1 54 2 23 3 100 4 35 5 45 6 24 7 97 8 56 \n0 10 1 8 2 8 3 81 4 81 5 24 6 26 7 22 8 47 \n0 85 1 48 2 35 3 24 4 20 5 68 6 64 7 51 8 59 \n0 87 1 73 2 23 3 3 4 62 5 86 6 73 7 33 8 20 \n0 1 1 31 2 97 3 61 4 36 5 44 6 25 7 74 8 18 \n0 75 1 38 2 85 3 32 4 8 5 90 6 47 7 57 8 84 \n0 8 1 55 2 57 3 89 4 20 5 91 6 89 7 14 8 68 \n0 90 1 42 2 37 3 73 4 97 5 95 6 54 7 34 8 23 \n0 7 1 9 2 28 3 83 4 96 5 39 6 62 7 65 8 68 \n0 87 1 94 2 96 3 1 4 84 5 7 6 14 7 8 8 66 \n0 41 1 53 2 86 3 12 4 54 5 77 6 23 7 26 8 49 \n0 36 1 88 2 64 3 29 4 32 5 88 6 20 7 17 8 34 \n0 51 1 81 2 12 3 75 4 70 5 93 6 31 7 87 8 9 \n0 80 1 56 2 100 3 17 4 26 5 88 6 35 7 2 8 13 \n0 2 1 92 2 15 3 10 4 7 5 13 6 42 7 85 8 96 \n0 90 1 18 2 49 3 46 4 35 5 66 6 82 7 97 8 95 \n0 21 1 11 2 21 3 93 4 55 5 60 6 3 7 36 8 78 \n" }, { "path": "examples/user_fssp_gls/TrainingData/61.txt", "content": "50 5\n0 42 1 31 2 16 3 65 4 77 \n0 25 1 88 2 34 3 1 4 22 \n0 59 1 61 2 48 3 30 4 24 \n0 71 1 44 2 50 3 59 4 17 \n0 58 1 75 2 9 3 9 4 90 \n0 50 1 44 2 25 3 89 4 81 \n0 100 1 90 2 65 3 92 4 34 \n0 63 1 45 2 26 3 66 4 81 \n0 72 1 46 2 19 3 90 4 43 \n0 5 1 12 2 54 3 16 4 74 \n0 25 1 57 2 83 3 52 4 36 \n0 37 1 16 2 81 3 15 4 70 \n0 27 1 39 2 78 3 18 4 50 \n0 90 1 39 2 32 3 4 4 17 \n0 96 1 53 2 26 3 13 4 96 \n0 83 1 14 2 7 3 77 4 22 \n0 84 1 62 2 15 3 56 4 23 \n0 1 1 5 2 88 3 99 4 99 \n0 29 1 87 2 20 3 83 4 10 \n0 59 1 29 2 87 3 7 4 40 \n0 35 1 31 2 52 3 96 4 30 \n0 82 1 11 2 88 3 72 4 72 \n0 1 1 48 2 34 3 33 4 4 \n0 68 1 64 2 22 3 31 4 87 \n0 5 1 34 2 67 3 86 4 75 \n0 70 1 91 2 100 3 63 4 25 \n0 11 1 91 2 16 3 57 4 88 \n0 79 1 52 2 39 3 89 4 87 \n0 23 1 76 2 25 3 58 4 46 \n0 32 1 9 2 48 3 75 4 73 \n0 79 1 61 2 41 3 8 4 51 \n0 73 1 46 2 85 3 27 4 49 \n0 35 1 28 2 3 3 51 4 19 \n0 57 1 69 2 19 3 76 4 21 \n0 56 1 13 2 68 3 95 4 91 \n0 15 1 22 2 82 3 80 4 22 \n0 26 1 40 2 67 3 82 4 38 \n0 43 1 15 2 50 3 63 4 49 \n0 28 1 72 2 84 3 89 4 71 \n0 37 1 89 2 6 3 91 4 46 \n0 96 1 93 2 8 3 41 4 10 \n0 33 1 77 2 34 3 97 4 18 \n0 73 1 24 2 2 3 7 4 77 \n0 7 1 100 2 30 3 22 4 69 \n0 27 1 22 2 47 3 96 4 65 \n0 14 1 69 2 18 3 33 4 94 \n0 67 1 7 2 27 3 5 4 26 \n0 40 1 35 2 10 3 46 4 10 \n0 38 1 51 2 7 3 11 4 33 \n0 47 1 49 2 12 3 55 4 92 \n" }, { "path": "examples/user_fssp_gls/TrainingData/62.txt", "content": "50 8\n0 28 1 61 2 2 3 22 4 59 5 57 6 65 7 70 \n0 65 1 30 2 61 3 99 4 67 5 95 6 90 7 2 \n0 91 1 55 2 63 3 97 4 99 5 54 6 63 7 51 \n0 86 1 38 2 5 3 1 4 89 5 40 6 84 7 51 \n0 72 1 95 2 84 3 59 4 17 5 10 6 14 7 22 \n0 85 1 20 2 79 3 82 4 5 5 20 6 14 7 10 \n0 83 1 39 2 84 3 52 4 85 5 23 6 82 7 31 \n0 91 1 93 2 25 3 88 4 54 5 65 6 64 7 10 \n0 91 1 68 2 48 3 55 4 28 5 9 6 35 7 85 \n0 11 1 19 2 23 3 19 4 98 5 71 6 100 7 37 \n0 43 1 96 2 94 3 77 4 10 5 73 6 54 7 95 \n0 99 1 89 2 73 3 51 4 30 5 54 6 32 7 95 \n0 36 1 50 2 49 3 29 4 39 5 27 6 49 7 92 \n0 59 1 61 2 31 3 93 4 75 5 47 6 97 7 96 \n0 45 1 50 2 51 3 65 4 84 5 46 6 35 7 79 \n0 82 1 55 2 99 3 20 4 45 5 24 6 34 7 46 \n0 59 1 41 2 17 3 87 4 70 5 42 6 59 7 98 \n0 82 1 14 2 33 3 30 4 59 5 3 6 6 7 38 \n0 35 1 24 2 5 3 60 4 83 5 33 6 74 7 45 \n0 93 1 10 2 43 3 72 4 79 5 25 6 92 7 84 \n0 62 1 85 2 20 3 5 4 41 5 46 6 58 7 18 \n0 91 1 69 2 44 3 71 4 14 5 20 6 54 7 50 \n0 76 1 90 2 46 3 7 4 87 5 56 6 38 7 48 \n0 68 1 98 2 76 3 38 4 94 5 74 6 39 7 88 \n0 89 1 75 2 25 3 89 4 95 5 81 6 11 7 74 \n0 77 1 55 2 66 3 30 4 22 5 41 6 64 7 33 \n0 94 1 31 2 90 3 11 4 61 5 85 6 86 7 62 \n0 17 1 41 2 90 3 36 4 55 5 58 6 59 7 72 \n0 14 1 11 2 73 3 98 4 64 5 1 6 96 7 48 \n0 9 1 25 2 19 3 79 4 3 5 35 6 63 7 98 \n0 75 1 10 2 49 3 50 4 75 5 73 6 47 7 44 \n0 74 1 85 2 19 3 41 4 33 5 29 6 30 7 44 \n0 69 1 7 2 30 3 82 4 73 5 81 6 35 7 31 \n0 69 1 60 2 95 3 23 4 88 5 16 6 94 7 29 \n0 58 1 9 2 100 3 36 4 5 5 96 6 85 7 78 \n0 80 1 42 2 77 3 36 4 8 5 86 6 5 7 96 \n0 92 1 28 2 30 3 81 4 22 5 41 6 23 7 7 \n0 90 1 28 2 28 3 26 4 85 5 79 6 94 7 11 \n0 48 1 47 2 10 3 77 4 62 5 29 6 1 7 27 \n0 100 1 23 2 53 3 58 4 91 5 30 6 90 7 3 \n0 63 1 57 2 68 3 53 4 85 5 50 6 12 7 94 \n0 39 1 99 2 69 3 40 4 30 5 31 6 51 7 19 \n0 92 1 12 2 66 3 45 4 42 5 27 6 66 7 81 \n0 41 1 27 2 70 3 89 4 64 5 92 6 50 7 48 \n0 88 1 60 2 7 3 85 4 60 5 100 6 14 7 71 \n0 9 1 20 2 100 3 49 4 49 5 9 6 98 7 22 \n0 63 1 13 2 12 3 17 4 70 5 71 6 11 7 86 \n0 11 1 78 2 9 3 36 4 71 5 95 6 6 7 37 \n0 56 1 57 2 42 3 7 4 76 5 27 6 100 7 55 \n0 35 1 25 2 95 3 83 4 9 5 100 6 2 7 24 \n" }, { "path": "examples/user_fssp_gls/TrainingData/63.txt", "content": "50 3\n0 77 1 63 2 26 \n0 92 1 1 2 9 \n0 56 1 97 2 78 \n0 17 1 34 2 100 \n0 22 1 84 2 79 \n0 10 1 16 2 33 \n0 22 1 56 2 69 \n0 76 1 75 2 92 \n0 64 1 69 2 64 \n0 68 1 43 2 65 \n0 13 1 61 2 28 \n0 74 1 88 2 59 \n0 11 1 88 2 98 \n0 90 1 83 2 68 \n0 81 1 61 2 89 \n0 31 1 27 2 4 \n0 89 1 23 2 25 \n0 3 1 67 2 57 \n0 73 1 87 2 96 \n0 37 1 57 2 87 \n0 61 1 29 2 51 \n0 77 1 35 2 52 \n0 31 1 40 2 63 \n0 60 1 20 2 34 \n0 67 1 83 2 58 \n0 57 1 26 2 41 \n0 57 1 10 2 27 \n0 21 1 99 2 31 \n0 67 1 52 2 82 \n0 90 1 41 2 47 \n0 83 1 11 2 7 \n0 27 1 54 2 96 \n0 40 1 21 2 69 \n0 77 1 36 2 7 \n0 24 1 4 2 38 \n0 80 1 41 2 33 \n0 32 1 87 2 66 \n0 4 1 69 2 69 \n0 90 1 51 2 60 \n0 81 1 75 2 44 \n0 17 1 93 2 48 \n0 67 1 57 2 97 \n0 50 1 82 2 61 \n0 60 1 87 2 97 \n0 80 1 24 2 56 \n0 99 1 93 2 21 \n0 18 1 14 2 35 \n0 50 1 2 2 69 \n0 20 1 49 2 51 \n0 15 1 82 2 22 \n" }, { "path": "examples/user_fssp_gls/TrainingData/64.txt", "content": "50 13\n0 10 1 80 2 83 3 44 4 25 5 60 6 96 7 26 8 25 9 82 10 14 11 21 12 98 \n0 31 1 18 2 76 3 43 4 31 5 37 6 37 7 58 8 38 9 37 10 97 11 91 12 22 \n0 32 1 6 2 56 3 81 4 93 5 69 6 93 7 51 8 60 9 28 10 46 11 81 12 54 \n0 67 1 84 2 47 3 17 4 55 5 57 6 74 7 28 8 53 9 10 10 48 11 72 12 99 \n0 81 1 45 2 17 3 23 4 98 5 25 6 47 7 37 8 64 9 8 10 36 11 65 12 68 \n0 93 1 11 2 59 3 25 4 22 5 58 6 70 7 26 8 99 9 95 10 88 11 99 12 87 \n0 94 1 97 2 58 3 8 4 10 5 80 6 35 7 80 8 22 9 62 10 20 11 11 12 11 \n0 39 1 15 2 18 3 65 4 24 5 41 6 28 7 38 8 97 9 36 10 28 11 83 12 90 \n0 96 1 91 2 2 3 32 4 62 5 60 6 27 7 39 8 87 9 81 10 7 11 96 12 21 \n0 71 1 31 2 81 3 73 4 59 5 52 6 67 7 17 8 8 9 33 10 24 11 18 12 76 \n0 34 1 87 2 73 3 10 4 46 5 39 6 9 7 32 8 16 9 18 10 38 11 16 12 45 \n0 52 1 2 2 93 3 69 4 84 5 67 6 2 7 52 8 24 9 42 10 74 11 44 12 100 \n0 87 1 52 2 8 3 7 4 88 5 46 6 6 7 2 8 43 9 66 10 67 11 51 12 62 \n0 8 1 2 2 90 3 70 4 53 5 1 6 19 7 42 8 25 9 69 10 2 11 17 12 94 \n0 52 1 59 2 76 3 7 4 1 5 90 6 86 7 24 8 10 9 12 10 53 11 70 12 11 \n0 98 1 11 2 38 3 88 4 78 5 40 6 13 7 39 8 54 9 57 10 55 11 62 12 95 \n0 57 1 67 2 1 3 1 4 89 5 72 6 66 7 70 8 64 9 97 10 50 11 88 12 7 \n0 88 1 6 2 37 3 74 4 44 5 26 6 27 7 60 8 82 9 58 10 87 11 72 12 18 \n0 46 1 47 2 50 3 3 4 60 5 31 6 27 7 34 8 69 9 65 10 47 11 41 12 49 \n0 32 1 50 2 12 3 69 4 11 5 35 6 7 7 100 8 3 9 13 10 26 11 83 12 3 \n0 63 1 29 2 41 3 58 4 50 5 88 6 41 7 47 8 68 9 95 10 8 11 2 12 93 \n0 81 1 22 2 6 3 84 4 95 5 30 6 37 7 85 8 65 9 47 10 17 11 34 12 44 \n0 46 1 30 2 22 3 8 4 15 5 66 6 6 7 98 8 61 9 31 10 82 11 53 12 87 \n0 13 1 61 2 74 3 52 4 47 5 64 6 2 7 27 8 57 9 7 10 71 11 51 12 58 \n0 29 1 38 2 91 3 95 4 25 5 91 6 74 7 34 8 97 9 5 10 95 11 26 12 62 \n0 9 1 5 2 8 3 51 4 18 5 86 6 58 7 38 8 39 9 8 10 85 11 14 12 19 \n0 81 1 77 2 11 3 28 4 83 5 63 6 52 7 80 8 27 9 47 10 44 11 39 12 53 \n0 1 1 22 2 51 3 94 4 49 5 21 6 60 7 55 8 21 9 55 10 63 11 32 12 99 \n0 56 1 68 2 37 3 99 4 1 5 14 6 87 7 34 8 49 9 68 10 59 11 64 12 87 \n0 4 1 94 2 7 3 87 4 79 5 2 6 48 7 31 8 80 9 21 10 24 11 18 12 66 \n0 58 1 77 2 85 3 74 4 44 5 59 6 34 7 44 8 22 9 47 10 47 11 76 12 30 \n0 78 1 46 2 91 3 78 4 62 5 30 6 69 7 88 8 2 9 100 10 82 11 89 12 4 \n0 17 1 12 2 3 3 3 4 73 5 16 6 83 7 94 8 20 9 97 10 4 11 18 12 79 \n0 100 1 42 2 91 3 6 4 75 5 100 6 93 7 94 8 67 9 12 10 62 11 67 12 8 \n0 89 1 37 2 40 3 73 4 11 5 35 6 4 7 25 8 23 9 74 10 61 11 52 12 45 \n0 36 1 50 2 62 3 64 4 61 5 22 6 14 7 76 8 1 9 84 10 65 11 42 12 14 \n0 58 1 40 2 7 3 65 4 81 5 96 6 57 7 79 8 65 9 33 10 14 11 61 12 10 \n0 84 1 50 2 92 3 47 4 34 5 85 6 61 7 83 8 52 9 68 10 1 11 64 12 20 \n0 79 1 42 2 75 3 91 4 80 5 19 6 6 7 61 8 35 9 63 10 16 11 72 12 74 \n0 54 1 96 2 14 3 31 4 43 5 84 6 62 7 50 8 62 9 46 10 50 11 92 12 3 \n0 14 1 72 2 78 3 94 4 40 5 63 6 37 7 64 8 91 9 6 10 31 11 31 12 42 \n0 96 1 11 2 4 3 95 4 60 5 71 6 83 7 99 8 85 9 35 10 2 11 45 12 7 \n0 6 1 20 2 60 3 94 4 40 5 78 6 30 7 4 8 16 9 76 10 73 11 64 12 14 \n0 4 1 36 2 50 3 42 4 29 5 64 6 17 7 18 8 24 9 24 10 13 11 4 12 70 \n0 45 1 79 2 21 3 42 4 89 5 53 6 84 7 93 8 89 9 99 10 88 11 10 12 62 \n0 43 1 82 2 45 3 50 4 29 5 14 6 33 7 53 8 98 9 84 10 45 11 45 12 21 \n0 67 1 53 2 23 3 44 4 62 5 54 6 73 7 2 8 16 9 45 10 86 11 69 12 85 \n0 2 1 45 2 12 3 56 4 20 5 87 6 2 7 22 8 53 9 65 10 90 11 41 12 21 \n0 45 1 56 2 57 3 3 4 15 5 29 6 31 7 9 8 79 9 32 10 48 11 81 12 77 \n0 1 1 93 2 2 3 19 4 84 5 9 6 56 7 65 8 12 9 11 10 42 11 16 12 28 \n" }, { "path": "examples/user_fssp_gls/TrainingData/7.txt", "content": "50 2\n0 43 1 33 \n0 61 1 55 \n0 68 1 33 \n0 10 1 19 \n0 44 1 12 \n0 13 1 79 \n0 32 1 22 \n0 87 1 47 \n0 63 1 51 \n0 42 1 21 \n0 100 1 62 \n0 12 1 59 \n0 54 1 73 \n0 78 1 17 \n0 25 1 36 \n0 44 1 53 \n0 89 1 10 \n0 7 1 55 \n0 89 1 50 \n0 87 1 46 \n0 23 1 80 \n0 53 1 79 \n0 96 1 12 \n0 79 1 83 \n0 43 1 91 \n0 88 1 40 \n0 98 1 10 \n0 35 1 68 \n0 20 1 76 \n0 27 1 58 \n0 41 1 77 \n0 83 1 81 \n0 61 1 19 \n0 17 1 15 \n0 83 1 96 \n0 79 1 28 \n0 1 1 69 \n0 94 1 48 \n0 28 1 77 \n0 57 1 74 \n0 16 1 55 \n0 11 1 94 \n0 11 1 25 \n0 35 1 51 \n0 69 1 94 \n0 30 1 52 \n0 38 1 31 \n0 15 1 77 \n0 92 1 37 \n0 21 1 55 \n" }, { "path": "examples/user_fssp_gls/TrainingData/8.txt", "content": "50 13\n0 3 1 69 2 30 3 27 4 57 5 88 6 4 7 71 8 21 9 95 10 10 11 36 12 7 \n0 93 1 3 2 57 3 84 4 63 5 64 6 49 7 9 8 12 9 65 10 12 11 34 12 11 \n0 80 1 13 2 39 3 67 4 2 5 31 6 5 7 13 8 47 9 74 10 77 11 57 12 35 \n0 74 1 43 2 43 3 54 4 74 5 67 6 41 7 48 8 2 9 55 10 100 11 73 12 12 \n0 17 1 21 2 43 3 8 4 89 5 87 6 91 7 96 8 84 9 26 10 33 11 34 12 45 \n0 78 1 51 2 27 3 59 4 45 5 27 6 34 7 12 8 10 9 84 10 42 11 50 12 60 \n0 9 1 58 2 90 3 42 4 82 5 81 6 20 7 26 8 68 9 94 10 19 11 22 12 71 \n0 91 1 58 2 73 3 36 4 72 5 14 6 92 7 67 8 87 9 35 10 54 11 78 12 35 \n0 81 1 52 2 81 3 15 4 96 5 99 6 18 7 70 8 73 9 88 10 51 11 79 12 77 \n0 19 1 36 2 26 3 88 4 79 5 34 6 1 7 33 8 36 9 58 10 27 11 38 12 27 \n0 58 1 21 2 88 3 1 4 39 5 80 6 62 7 25 8 14 9 54 10 23 11 63 12 20 \n0 29 1 8 2 54 3 71 4 46 5 26 6 100 7 77 8 35 9 46 10 30 11 9 12 43 \n0 4 1 70 2 82 3 35 4 59 5 3 6 49 7 48 8 21 9 49 10 70 11 96 12 79 \n0 17 1 53 2 60 3 46 4 16 5 80 6 93 7 87 8 75 9 96 10 55 11 47 12 38 \n0 42 1 5 2 98 3 28 4 31 5 65 6 46 7 50 8 63 9 35 10 30 11 43 12 28 \n0 91 1 49 2 79 3 57 4 85 5 73 6 31 7 84 8 97 9 75 10 73 11 48 12 63 \n0 79 1 90 2 2 3 15 4 38 5 39 6 69 7 49 8 24 9 20 10 74 11 40 12 95 \n0 92 1 26 2 58 3 80 4 4 5 59 6 71 7 46 8 39 9 88 10 58 11 46 12 74 \n0 18 1 78 2 74 3 67 4 33 5 90 6 80 7 90 8 64 9 63 10 83 11 90 12 95 \n0 76 1 59 2 55 3 11 4 85 5 28 6 78 7 80 8 41 9 61 10 90 11 84 12 53 \n0 83 1 29 2 16 3 97 4 49 5 43 6 62 7 49 8 85 9 44 10 10 11 63 12 58 \n0 21 1 95 2 6 3 80 4 52 5 68 6 13 7 39 8 30 9 10 10 98 11 48 12 2 \n0 82 1 91 2 37 3 77 4 56 5 93 6 47 7 37 8 2 9 56 10 21 11 92 12 67 \n0 14 1 58 2 28 3 84 4 96 5 3 6 69 7 25 8 38 9 27 10 13 11 4 12 68 \n0 95 1 89 2 71 3 44 4 87 5 99 6 40 7 17 8 4 9 19 10 14 11 83 12 20 \n0 1 1 37 2 88 3 4 4 76 5 2 6 12 7 66 8 66 9 36 10 34 11 72 12 33 \n0 39 1 90 2 66 3 53 4 43 5 20 6 49 7 23 8 98 9 26 10 71 11 17 12 22 \n0 13 1 1 2 95 3 30 4 100 5 44 6 54 7 55 8 28 9 84 10 7 11 1 12 73 \n0 8 1 34 2 86 3 54 4 37 5 56 6 40 7 65 8 3 9 32 10 72 11 57 12 75 \n0 50 1 58 2 93 3 39 4 87 5 37 6 10 7 75 8 59 9 41 10 79 11 79 12 96 \n0 6 1 93 2 53 3 63 4 83 5 10 6 88 7 46 8 74 9 35 10 9 11 73 12 69 \n0 54 1 45 2 74 3 61 4 88 5 47 6 100 7 87 8 98 9 100 10 70 11 93 12 9 \n0 77 1 99 2 19 3 38 4 78 5 71 6 76 7 21 8 5 9 18 10 84 11 98 12 37 \n0 94 1 17 2 52 3 63 4 14 5 44 6 1 7 22 8 87 9 99 10 91 11 62 12 39 \n0 3 1 31 2 90 3 39 4 79 5 81 6 24 7 48 8 15 9 58 10 44 11 49 12 31 \n0 41 1 51 2 54 3 54 4 21 5 77 6 21 7 12 8 3 9 26 10 66 11 78 12 87 \n0 48 1 40 2 19 3 60 4 38 5 97 6 92 7 70 8 79 9 50 10 95 11 26 12 41 \n0 35 1 19 2 19 3 57 4 3 5 87 6 86 7 49 8 64 9 9 10 20 11 54 12 61 \n0 44 1 39 2 93 3 64 4 78 5 62 6 39 7 46 8 15 9 63 10 9 11 42 12 47 \n0 67 1 43 2 23 3 27 4 80 5 67 6 58 7 100 8 45 9 93 10 88 11 40 12 61 \n0 76 1 89 2 86 3 10 4 82 5 27 6 93 7 5 8 19 9 19 10 93 11 63 12 100 \n0 78 1 81 2 35 3 65 4 36 5 67 6 56 7 65 8 66 9 76 10 34 11 16 12 79 \n0 14 1 39 2 11 3 4 4 15 5 26 6 88 7 77 8 77 9 34 10 79 11 19 12 13 \n0 55 1 78 2 78 3 53 4 65 5 85 6 90 7 86 8 54 9 50 10 1 11 10 12 53 \n0 3 1 5 2 47 3 66 4 70 5 34 6 43 7 38 8 83 9 80 10 30 11 51 12 23 \n0 55 1 84 2 20 3 35 4 29 5 63 6 9 7 7 8 76 9 6 10 83 11 62 12 51 \n0 44 1 85 2 64 3 50 4 54 5 9 6 70 7 62 8 60 9 75 10 56 11 32 12 22 \n0 53 1 65 2 65 3 85 4 82 5 40 6 30 7 64 8 1 9 16 10 98 11 64 12 60 \n0 20 1 10 2 69 3 97 4 71 5 72 6 35 7 78 8 30 9 76 10 98 11 75 12 54 \n0 55 1 63 2 95 3 33 4 6 5 91 6 38 7 21 8 86 9 23 10 31 11 61 12 90 \n" }, { "path": "examples/user_fssp_gls/TrainingData/9.txt", "content": "50 13\n0 72 1 95 2 36 3 6 4 87 5 86 6 13 7 54 8 67 9 10 10 43 11 41 12 4 \n0 76 1 22 2 75 3 7 4 85 5 37 6 54 7 71 8 32 9 74 10 45 11 86 12 68 \n0 70 1 12 2 53 3 5 4 53 5 37 6 18 7 47 8 17 9 77 10 40 11 68 12 65 \n0 16 1 60 2 46 3 6 4 21 5 2 6 10 7 23 8 57 9 87 10 73 11 82 12 42 \n0 7 1 35 2 10 3 10 4 12 5 82 6 32 7 6 8 33 9 48 10 32 11 3 12 88 \n0 49 1 40 2 38 3 72 4 97 5 59 6 62 7 72 8 51 9 15 10 100 11 88 12 45 \n0 15 1 24 2 24 3 93 4 13 5 88 6 27 7 10 8 2 9 95 10 69 11 37 12 24 \n0 9 1 49 2 93 3 31 4 73 5 38 6 27 7 43 8 53 9 40 10 93 11 62 12 44 \n0 60 1 100 2 39 3 58 4 73 5 67 6 38 7 59 8 22 9 46 10 56 11 43 12 56 \n0 15 1 13 2 11 3 50 4 32 5 86 6 38 7 8 8 30 9 92 10 27 11 92 12 22 \n0 46 1 53 2 97 3 82 4 64 5 8 6 1 7 70 8 45 9 31 10 40 11 67 12 75 \n0 12 1 54 2 61 3 95 4 48 5 81 6 47 7 53 8 53 9 90 10 76 11 97 12 30 \n0 33 1 91 2 83 3 74 4 91 5 89 6 53 7 39 8 69 9 32 10 67 11 68 12 90 \n0 22 1 84 2 56 3 71 4 57 5 9 6 85 7 15 8 27 9 93 10 44 11 32 12 84 \n0 87 1 37 2 93 3 59 4 100 5 7 6 47 7 88 8 42 9 12 10 25 11 34 12 22 \n0 3 1 56 2 11 3 59 4 31 5 84 6 10 7 91 8 31 9 26 10 82 11 63 12 47 \n0 40 1 55 2 83 3 93 4 29 5 77 6 1 7 63 8 37 9 48 10 18 11 69 12 40 \n0 58 1 20 2 13 3 93 4 41 5 34 6 12 7 27 8 2 9 70 10 96 11 72 12 64 \n0 59 1 23 2 48 3 87 4 11 5 53 6 35 7 85 8 10 9 50 10 85 11 22 12 79 \n0 67 1 98 2 46 3 27 4 55 5 78 6 45 7 84 8 68 9 94 10 45 11 2 12 7 \n0 74 1 74 2 14 3 54 4 26 5 16 6 28 7 66 8 86 9 76 10 60 11 31 12 32 \n0 15 1 17 2 41 3 96 4 87 5 70 6 63 7 57 8 33 9 2 10 34 11 33 12 44 \n0 40 1 53 2 13 3 19 4 87 5 20 6 53 7 89 8 35 9 49 10 58 11 52 12 80 \n0 29 1 55 2 68 3 81 4 78 5 30 6 88 7 51 8 79 9 66 10 5 11 79 12 2 \n0 10 1 13 2 85 3 86 4 23 5 93 6 23 7 72 8 9 9 19 10 62 11 53 12 10 \n0 99 1 48 2 75 3 97 4 3 5 53 6 83 7 62 8 97 9 87 10 53 11 71 12 100 \n0 95 1 4 2 50 3 98 4 51 5 74 6 18 7 60 8 45 9 77 10 34 11 35 12 50 \n0 42 1 45 2 66 3 25 4 3 5 65 6 47 7 37 8 32 9 44 10 36 11 50 12 6 \n0 9 1 78 2 70 3 62 4 53 5 73 6 15 7 56 8 23 9 73 10 78 11 2 12 20 \n0 84 1 78 2 24 3 78 4 45 5 68 6 66 7 96 8 37 9 94 10 60 11 21 12 46 \n0 12 1 43 2 89 3 63 4 7 5 18 6 18 7 88 8 23 9 35 10 35 11 42 12 86 \n0 85 1 52 2 40 3 40 4 42 5 39 6 34 7 93 8 75 9 16 10 74 11 18 12 4 \n0 18 1 77 2 31 3 33 4 20 5 39 6 42 7 77 8 26 9 61 10 55 11 6 12 90 \n0 92 1 89 2 29 3 39 4 31 5 44 6 60 7 14 8 3 9 31 10 3 11 32 12 100 \n0 49 1 96 2 89 3 21 4 25 5 25 6 76 7 74 8 8 9 19 10 76 11 18 12 3 \n0 50 1 45 2 71 3 57 4 80 5 78 6 2 7 88 8 97 9 48 10 83 11 18 12 34 \n0 31 1 19 2 7 3 32 4 18 5 60 6 16 7 63 8 28 9 69 10 39 11 32 12 62 \n0 11 1 64 2 91 3 58 4 38 5 26 6 14 7 7 8 3 9 78 10 52 11 34 12 50 \n0 19 1 6 2 12 3 80 4 70 5 31 6 67 7 12 8 20 9 93 10 50 11 65 12 90 \n0 15 1 93 2 97 3 33 4 9 5 85 6 35 7 98 8 19 9 6 10 3 11 48 12 25 \n0 85 1 46 2 73 3 24 4 82 5 55 6 68 7 100 8 78 9 62 10 64 11 26 12 6 \n0 32 1 27 2 55 3 59 4 51 5 11 6 69 7 59 8 50 9 11 10 40 11 81 12 100 \n0 18 1 80 2 22 3 63 4 25 5 79 6 49 7 67 8 48 9 48 10 44 11 78 12 70 \n0 11 1 27 2 78 3 93 4 73 5 1 6 60 7 84 8 61 9 21 10 90 11 26 12 89 \n0 85 1 39 2 49 3 100 4 49 5 63 6 38 7 21 8 21 9 49 10 42 11 37 12 98 \n0 44 1 53 2 69 3 52 4 85 5 30 6 27 7 85 8 7 9 38 10 16 11 17 12 5 \n0 75 1 83 2 20 3 43 4 53 5 21 6 22 7 2 8 83 9 92 10 14 11 23 12 44 \n0 29 1 67 2 47 3 77 4 10 5 1 6 41 7 37 8 70 9 24 10 88 11 89 12 88 \n0 88 1 15 2 91 3 13 4 97 5 88 6 78 7 28 8 78 9 55 10 79 11 86 12 18 \n0 40 1 8 2 49 3 83 4 49 5 35 6 50 7 59 8 3 9 98 10 72 11 7 12 48 \n" }, { "path": "examples/user_fssp_gls/TrainingData/instance_generator.py", "content": "import random\n\nn = 50\nnum_instances = 64\n\nfor instance in range(num_instances):\n m = random.randint(2, 20)\n processing_times = [[random.randint(1, 100) for _ in range(m)] for _ in range(n)]\n file_name = f\"{instance + 1}.txt\"\n with open(file_name, 'w') as file:\n file.write(f\"{n} {m}\\n\")\n for i in range(n):\n for j in range(m):\n file.write(f\"{j} {processing_times[i][j]} \")\n file.write(\"\\n\")" }, { "path": "examples/user_fssp_gls/jssp/bruteforce.py", "content": "import numpy as np\nfrom prettytable import PrettyTable\n\n\ndef permute(x, index=0):\n if index+1 >= len(x):\n yield x\n else:\n for p in permute(x, index+1):\n yield p\n for i in range(index+1,len(x)):\n x[index], x[i]=x[i], x[index]\n for p in permute(x,index+1):\n yield p\n x[index], x[i]=x[i], x[index]\n\n\ndef makespan(order, tasks, machines_val):\n times = []\n for i in range(0, machines_val):\n times.append(0)\n for j in order:\n times[0] += tasks[j][0]\n for k in range(1, machines_val):\n if times[k] < times[k-1]:\n times[k] = times[k-1]\n times[k] += tasks[j][k]\n return max(times)\n\n\ndef bruteforce(tasks, machines_val, tasks_val):\n figure = PrettyTable()\n figure.field_names = [\"Sequence\", \"Makespan\"]\n print(\"Starting bruteforce\")\n t = []\n min_time = 1000\n for z in range(0, tasks_val):\n t.append(z)\n for p in permute(t):\n tmp = makespan(p, tasks, machines_val)\n figure.add_row([format(p), tmp ])\n if (tmp < min_time):\n min_time = tmp\n best_permute = format(p)\n print(figure)\n print(\"Min time:\", min_time, \" for :\", format(best_permute), \"permutation\")\n print(\"Bruteforce: DONE\")\n\n\ndef read_data(filename):\n file = open(filename, \"r\")\n\n tasks_val, machines_val = file.readline().split()\n tasks_val = int(tasks_val)\n machines_val = int(machines_val)\n\n tasks = np.zeros((tasks_val,machines_val))\n for i in range(tasks_val):\n tmp = file.readline().split()\n for j in range(machines_val):\n tasks[i][j] = int(tmp[j])\n\n print(\"Number of tasks: \", tasks_val)\n print(\"Number of machines: \", machines_val)\n print(\"Tasks: \\n\", tasks)\n file.close()\n return tasks_val, machines_val, tasks\n\nif __name__==\"__main__\":\n TWO_OR_THREE = 3 # Two or three machines algorithm??\n print(\"Starting program...\")\n\n if (TWO_OR_THREE == 2):\n tasks_num, machines_num, tasks = read_data(\"data/flowshop_2machines.txt\")\n if (TWO_OR_THREE == 3):\n tasks_num, machines_num, tasks = read_data(\"data/flowshop_3machines.txt\")\n\n bruteforce(tasks, machines_num, tasks_num)\n" }, { "path": "examples/user_fssp_gls/jssp/get_ub.py", "content": "import os\nimport numpy as np\ndef read_taillard_instances(path):\n tasks_val_list = [] \n machines_val_list = [] \n tasks_list = []\n names = []\n\n files = os.listdir(path)\n\n with open('ub_lb.txt', 'w') as f:\n\n for filename in files:\n file = open(os.path.join(path, filename), \"r\")\n\n while True:\n file.readline()\n line = file.readline().strip()\n if line == \"\":\n break\n\n tasks_val, machines_val, _, ub, lb = map(int, line.split())\n tasks = np.zeros((tasks_val, machines_val))\n file.readline()\n for i in range(machines_val):\n line = file.readline().strip()\n tmp = list(map(int, line.split()))\n for j in range(tasks_val):\n tasks[j][i] = tmp[j]\n\n tasks_val_list.append(tasks_val)\n machines_val_list.append(machines_val)\n tasks_list.append(tasks)\n names.append(filename)\n\n print(f\"{filename}, {tasks_val}, {machines_val}, {ub}, {lb}\", file=f, flush=True)\n\n file.close()\n\n return\n\n\nins_path = '../data/Taillard/'\nread_taillard_instances(ins_path)" }, { "path": "examples/user_fssp_gls/jssp/johnsons.py", "content": "import numpy as np\nfrom prettytable import PrettyTable\n\n\ndef johnson_algorithm(machines_val, tasks):\n print(\"\\n Johnson algorithm: START\")\n if(machines_val == 2):\n print(\"Two machines algorithm: START\")\n return johnson2m(tasks)\n if (machines_val == 3):\n print(\"Three machines algorithm\")\n return johnson3m(tasks)\n\n\ndef johnson2m(tasks):\n mt_row = 0\n mt_column = 0\n tab1 = []\n tab2 = []\n iter = 0\n while(iter != len(tasks)):\n min_time = 100\n for i in range(0, len(tasks)):\n for j in range(0, len(tasks[i])):\n if(min_time > tasks[i][j]):\n min_time = tasks[i][j]\n mt_row = i\n mt_column = j\n tasks[mt_row] = 1000\n\n if (mt_column == 0):\n tab1.append(mt_row)\n if (mt_column == 1):\n tab2.append(mt_row)\n iter = iter +1\n\n sequence = tab1 + list(reversed(tab2))\n print(\"Best sequence: \", sequence)\n print(\"Two machines algorithm: DONE\")\n\n\ndef transform3to2(tasks):\n virtual = np.zeros((len(tasks),2))\n\n for i in range(0, len(tasks)):\n virtual[i][0] = tasks[i][0] + tasks[i][1]\n virtual[i][1] = tasks[i][1] + tasks[i][2]\n\n print(\"Virtual machines: \\n\", virtual)\n return virtual\n\n\ndef johnson3m(tasks):\n virtual_machine = transform3to2(tasks)\n johnson2m(virtual_machine)\n print(\"Three machines algorithm: DONE\")\n\n\ndef read_data(filename):\n file = open(filename, \"r\")\n\n tasks_val, machines_val = file.readline().split()\n tasks_val = int(tasks_val)\n machines_val = int(machines_val)\n\n tasks = np.zeros((tasks_val,machines_val))\n for i in range(tasks_val):\n tmp = file.readline().split()\n for j in range(machines_val):\n tasks[i][j] = int(tmp[j])\n\n print(\"Number of tasks: \", tasks_val)\n print(\"Number of machines: \", machines_val)\n print(\"Tasks: \\n\", tasks)\n file.close()\n return tasks_val, machines_val, tasks\n\nif __name__==\"__main__\":\n TWO_OR_THREE = 3 # Two or three machines algorithm??\n print(\"Starting program...\")\n\n if (TWO_OR_THREE == 2):\n tasks_num, machines_num, tasks = read_data(\"data/flowshop_2machines.txt\")\n if (TWO_OR_THREE == 3):\n tasks_num, machines_num, tasks = read_data(\"data/flowshop_3machines.txt\")\n\n johnson_algorithm(machines_num, tasks)" }, { "path": "examples/user_fssp_gls/jssp/neh.py", "content": "import numpy as np\nimport time\nfrom prettytable import PrettyTable\n\n################################################# CLASSICAL APPROACH ###############################################\ndef makespan(order, tasks, machines_val):\n times = []\n for i in range(0, machines_val):\n times.append(0)\n for j in order:\n times[0] += tasks[j][0]\n for k in range(1, machines_val):\n if times[k] < times[k-1]:\n times[k] = times[k-1]\n times[k] += tasks[j][k]\n return max(times)\n\n\ndef sum_and_order(tasks_val, machines_val, tasks):\n tab = []\n tab1 = []\n for i in range(0, tasks_val):\n tab.append(0)\n tab1.append(0)\n for j in range(0, tasks_val):\n for k in range(0, machines_val):\n tab[j] += tasks[j][k]\n place = 0\n iter = 0\n while(iter != tasks_val):\n max_time = 0\n for i in range(0, tasks_val):\n if(max_time < tab[i]):\n max_time = tab[i]\n place = i\n tab[place] = 1\n tab1[iter] = place\n iter = iter + 1\n return tab1\n\n\ndef insert(sequence, position, value):\n new_seq = sequence[:]\n new_seq.insert(position, value)\n return new_seq\n\n\ndef neh(tasks, machines_val, tasks_val):\n order = sum_and_order(tasks_val, machines_val, tasks)\n current_seq = [order[0]]\n for i in range(1, tasks_val):\n min_cmax = float(\"inf\")\n for j in range(0, i + 1):\n tmp = insert(current_seq, j, order[i])\n cmax_tmp = makespan(tmp, tasks, machines_val)\n if min_cmax > cmax_tmp:\n best_seq = tmp\n min_cmax = cmax_tmp\n current_seq = best_seq\n return current_seq, makespan(current_seq, tasks, machines_val)\n\n\n######################################################### NEH + ACCELERATION ###########################################\n\ndef create_graph_LR(seq, tasks, machines_val):\n tasks_val = len(seq)\n graf = []\n for i in seq:\n graf.append(tasks[i])\n\n graf_wag = []\n for j in range(0, tasks_val):\n graf_wag.append([0]*machines_val)\n\n for i in range(0, len(graf)):\n if i == 0:\n for j in range(0, machines_val):\n if j==0:\n graf_wag[i][j] = graf[i][j]\n else:\n graf_wag[i][j] = graf[i][j] + graf_wag[i][j-1]\n\n else:\n for j in range(0, machines_val):\n if j==0:\n graf_wag[i][j] = graf[i][j] + graf_wag[i-1][j]\n else:\n graf_wag[i][j] = graf[i][j] + max( graf_wag[i-1][j], graf_wag[i][j-1])\n Cmax = graf_wag[-1][-1]\n\n i = 0\n j = 0\n sciezka = []\n while (i !=len(graf)-1)or(j!=machines_val-1) :\n if graf_wag[len(graf)-i-1][machines_val-j-1]-graf[len(graf)-i-1][machines_val-j-1] == graf_wag[len(graf)-i-2][machines_val-j-1]:\n sciezka.append([len(graf)-i-1, machines_val-j-1])\n i = i+1\n\n elif graf_wag[len(graf)-i-1][machines_val-j-1]-graf[len(graf)-i-1][machines_val-j-1] == graf_wag[len(graf)-i-1][machines_val-j-2]:\n sciezka.append([len(graf)-i-1, machines_val-j-1])\n j = j+1\n sciezka.append([0, 0])\n\n return sciezka, graf, graf_wag\n\n\ndef create_graph_RL(seq, tasks, machines_val):\n tasks_val = len(seq)\n graf = []\n for i in seq:\n graf.append(tasks[i])\n\n graf_wag = []\n for j in range(0, tasks_val):\n graf_wag.append([0]*machines_val)\n\n for i in range(1, len(graf)+1):\n if i == 0:\n for j in range(1, machines_val+1):\n if j==0:\n graf_wag[-i][-j] = graf[-\n i][-j]\n else:\n graf_wag[-i][-j] = graf[-i][-j] + graf_wag[-i][-j+1]\n else:\n for j in range(1, machines_val+1):\n if j==0:\n graf_wag[-i][-j] = graf[-i][-j] + graf_wag[-i+1][-j]\n else:\n graf_wag[-i][-j] = graf[-i][-j] + max( graf_wag[-i+1][-j], graf_wag[-i][-j+1])\n\n Cmax = graf_wag[0][0]\n return graf_wag\n\n\ndef makespan_acc(order, weight_LR, weight_RL, tasks, new_elem):\n Cmax = []\n for i in range(len(weight_RL) + 1):\n temp = []\n C = []\n if i == 0:\n for j in range(len(tasks[new_elem])):\n if j == 0:\n temp.append(tasks[new_elem][j])\n else:\n temp.append(tasks[new_elem][j] + temp[j - 1])\n C.append(temp[j] + weight_RL[i][j])\n Cmax.append(max(C))\n elif i == len(weight_RL):\n for j in range(len(tasks[new_elem])):\n if j == 0:\n temp.append(tasks[new_elem][j] + weight_LR[i - 1][j])\n else:\n temp.append(tasks[new_elem][j] + max(weight_LR[i - 1][j], temp[j - 1]))\n C.append(temp[j])\n Cmax.append(max(C))\n else:\n for j in range(len(tasks[new_elem])):\n if j == 0:\n temp.append(tasks[new_elem][j] + weight_LR[i - 1][j])\n else:\n temp.append(tasks[new_elem][j] + max(weight_LR[i - 1][j], temp[j - 1]))\n C.append(temp[j] + weight_RL[i][j])\n Cmax.append(max(C))\n miejsce = Cmax.index(min(Cmax))\n order.insert(miejsce, new_elem)\n return order, min(Cmax)\n\n\ndef neh_acc(tasks, machines_val, tasks_val):\n order = sum_and_order(tasks_val, machines_val, tasks)\n k=0\n for i in order:\n if k == 0:\n current_seq = [order[0]]\n path, graph, weight_LR = create_graph_LR(current_seq, tasks, machines_val)\n weight_RL = create_graph_RL(current_seq, tasks, machines_val)\n k+=1\n else:\n path, graph, weight_LR = create_graph_LR(current_seq, tasks, machines_val)\n weight_RL = create_graph_RL(current_seq, tasks, machines_val)\n current_seq, Cmax = makespan_acc(current_seq, weight_LR, weight_RL, tasks, i)\n return current_seq, Cmax\n\n\n############################################## MODDIFICATION USING INSERTION METHOD ###################################\n\ndef neh_wm(tasks, machines_val, tasks_val):\n order = sum_and_order(tasks_val, machines_val, tasks)\n k = 0\n for i in order:\n if k == 0:\n current_seq = [order[0]]\n path, graph, weight_LR = create_graph_LR(current_seq, tasks, machines_val)\n weight_RL = create_graph_RL(current_seq, tasks, machines_val)\n k += 1\n else:\n path, graph, weight_LR = create_graph_LR(current_seq, tasks, machines_val)\n weight_RL = create_graph_RL(current_seq, tasks, machines_val)\n current_seq, Cmax = makespan_acc(current_seq, weight_LR, weight_RL, tasks, i)\n\n MOD = NEH_IR1(path, graph, i , current_seq)\n if MOD!= -1:\n current_seq.remove(MOD)\n path, graph, weight_LR = create_graph_LR(current_seq, tasks, machines_val)\n weight_RL = create_graph_RL(current_seq, tasks, machines_val)\n current_seq, Cmax = makespan_acc(current_seq, weight_LR, weight_RL, tasks, MOD)\n return current_seq, Cmax\n\n\ndef NEH_IR1(sciezka, graf, i, kolejnosc):\n max = 0\n index = 999\n zadanie_odrzucone = 999\n for k in range(len(kolejnosc)):\n if i == kolejnosc[k]:\n zadanie_odrzucone = k\n for i in sciezka:\n if i[0] != zadanie_odrzucone:\n if graf[i[0]][i[1]] > max:\n max = graf[i[0]][i[1]]\n index = i[0]\n if index == 999:\n return -1\n return kolejnosc[index]\n\n\n################################################ READ DATA ###########################################################\ndef read_data(filename):\n file = open(filename, \"r\")\n\n tasks_val, machines_val = file.readline().split()\n tasks_val = int(tasks_val)\n machines_val = int(machines_val)\n\n tasks = np.zeros((tasks_val,machines_val))\n for i in range(tasks_val):\n tmp = file.readline().split()\n for j in range(machines_val):\n tasks[i][j] = int(tmp[j])\n\n print(\"Number of tasks: \", tasks_val)\n print(\"Number of machines: \", machines_val)\n print(\"Tasks: \\n\", tasks)\n file.close()\n return tasks_val, machines_val, tasks\n\n\nif __name__==\"__main__\":\n print(\"Starting algorithm... \")\n table = PrettyTable()\n table.field_names = [\"Algorithm\", \"Cmax\", \"Execution time\"]\n\n tasks_val, machines_val, tasks = read_data(\"data/flowshop_neh.txt\")\n\n print(\"Clasic neh\")\n start = time.perf_counter()\n seq, cmax = neh(tasks, machines_val, tasks_val)\n stop = time.perf_counter()\n print(\"Best Cmax: \", cmax)\n print(\"Time: \", round((stop - start), 3))\n table.add_row([\"Classic\", cmax, round((stop - start), 3)])\n\n print(\"Modificated neh\")\n start = time.perf_counter()\n seq, cmax = neh_wm(tasks, machines_val, tasks_val)\n stop = time.perf_counter()\n print(\"Best Cmax: \", cmax)\n print(\"Time: \", round((stop - start), 3))\n table.add_row([\"Modif\", cmax, round((stop - start), 3)])\n\n print(\"Accelerated neh\")\n start = time.perf_counter()\n seq, cmax = neh_acc(tasks, machines_val, tasks_val)\n stop = time.perf_counter()\n print(\"Best Cmax: \", cmax)\n print(\"Time: \", round((stop - start), 3))\n table.add_row([\"Acc\", cmax, round((stop - start), 3)])\n\n print(\"Acceledated + modif neh:\")\n start = time.perf_counter()\n seq, cmax = neh_wm(tasks, machines_val, tasks_val)\n stop = time.perf_counter()\n policzony = round((stop - start), 3)\n table.add_row([\"Acc + modif\", cmax, round((stop - start), 3)])\n\n\n print(table)" }, { "path": "examples/user_fssp_gls/jssp/simulated_annealing.py", "content": "import numpy as np\nimport random\nimport math\nfrom numba import jit\nimport time\n\n@jit(nopython=True)\ndef makespan(order, tasks, machines_val):\n times = []\n for i in range(0, machines_val):\n times.append(0)\n for j in order:\n times[0] += tasks[j][0]\n for k in range(1, machines_val):\n if times[k] < times[k-1]:\n times[k] = times[k-1]\n times[k] += tasks[j][k]\n return max(times)\n\n\ndef insert(sequence, tasks_val):\n a = random.randrange(0, tasks_val)\n b = random.randrange(0, tasks_val)\n new_seq = sequence[:]\n new_seq.remove(a)\n new_seq.insert(b, a)\n return new_seq\n\n\ndef swap(list, tasks_val):\n a = random.randrange(0, tasks_val)\n b = random.randrange(0, tasks_val)\n tmp_list = list.copy()\n tmp = tmp_list[a]\n tmp_list[a] = tmp_list[b]\n tmp_list[b] = tmp\n return tmp_list\n\n\ndef probability(Cold, Cnew, Temp):\n if Cnew < Cold:\n prob = 1\n else:\n prob = math.exp((Cold-Cnew)/Temp)\n return prob\n\ndef annealing1(T, u):\n return T*u\n\n@jit(nopython=True)\ndef local_search(sequence, cmax_old,tasks,machines_val):\n new_seq = sequence[:]\n for i in range(len(new_seq)):\n for j in range(i+1, len(new_seq)):\n temp_seq = new_seq[:]\n temp_seq[i], temp_seq[j] = temp_seq[j], temp_seq[i]\n cmax = makespan(temp_seq, tasks, machines_val)\n if cmax < cmax_old: # Assuming cmax_old is defined in sim_ann1 function\n new_seq = temp_seq[:]\n cmax_old = cmax\n #print(cmax)\n\n for i in range(1,len(new_seq)):\n for j in range(1,len(new_seq)):\n temp_seq = new_seq[:]\n temp_seq.remove(i)\n temp_seq.insert(j, i)\n cmax = makespan(temp_seq, tasks, machines_val)\n if cmax < cmax_old: # Assuming cmax_old is defined in sim_ann1 function\n new_seq = temp_seq[:]\n cmax_old = cmax\n #print(cmax)\n\n return new_seq\n\n############################################### CLASSICAL APPROACH ####################################################\ndef sim_ann1(tasks_val, tasks, machines_val, T_start, T_end):\n pi0, cmax0 = neh(tasks, machines_val, tasks_val) \n pi = pi0\n cmax_old = cmax0\n T0 = T_start\n T = T0\n u = 0.99\n Tgr = T_end\n while (T >= Tgr):\n #piprim = local_search(pi, tasks_val)\n piprim = local_search(pi, cmax_old,tasks,machines_val)\n cmax = makespan(piprim, tasks, machines_val)\n p = probability(cmax_old, cmax, T)\n s = random.random()\n if p >= s:\n pi = piprim\n cmax_old = cmax\n T = annealing1(T, u)\n else:\n T = annealing1(T, u)\n return pi, cmax_old\n\n\n############################################# DIFFERENT ANNEALING FUNCTION ###########################################\ndef annealing2(T, k, kmax):\n return T*(k/kmax)\n\ndef sim_ann2(tasks_val, tasks, machines_val, T_start, T_end, iter_val):\n pi0, cmax0 = neh(tasks, machines_val, tasks_val)\n pi = pi0\n cmax_old = cmax0\n T0 = T_start\n T = T0\n u = 0.99\n Tgr = T_end\n iter = 0\n max_iter = iter_val\n\n for i in range(0, max_iter):\n iter = iter + 1\n piprim = local_search(pi, cmax_old)\n cmax = makespan(piprim, tasks, machines_val)\n p = probability(cmax_old, cmax, T)\n s = random.random()\n if p >= s:\n pi = piprim\n cmax_old = cmax\n T = annealing2(T, iter, max_iter)\n else:\n T = annealing2(T, iter, max_iter)\n if T == 0:\n break\n return pi, cmax_old\n\n\n\n############################################### Local Search ####################################################\ndef ls(tasks_val, tasks, machines_val):\n pi0, cmax0 = neh(tasks, machines_val, tasks_val) \n #print(\"neh results: \",cmax0) \n pi = pi0\n cmax_old = cmax0\n while True:\n #piprim = local_search(pi, tasks_val)\n piprim = local_search(pi, cmax_old,tasks,machines_val)\n cmax = makespan(piprim, tasks, machines_val)\n if (cmax>=cmax_old):\n break\n else:\n pi = piprim\n cmax_old = cmax\n return pi, cmax_old\n\n############################################### Iterated Local Search ####################################################\ndef gls(tasks_val, tasks, machines_val):\n pi0, cmax0 = neh(tasks, machines_val, tasks_val) \n print(\"neh results: \",cmax0) \n pi = pi0\n cmax_old = cmax0\n while True:\n #piprim = local_search(pi, tasks_val)\n piprim = local_search(pi, cmax_old)\n cmax = makespan(piprim, tasks, machines_val)\n if (cmax>=cmax_old):\n break\n else:\n pi = piprim\n cmax_old = cmax\n return pi, cmax_old\n\n###################################################################### NEH ############################################\ndef sum_and_order(tasks_val, machines_val, tasks):\n tab = []\n tab1 = []\n for i in range(0, tasks_val):\n tab.append(0)\n tab1.append(0)\n for j in range(0, tasks_val):\n for k in range(0, machines_val):\n tab[j] += tasks[j][k]\n tmp_tab = tab.copy()\n place = 0\n iter = 0\n while(iter != tasks_val):\n max_time = 1\n for i in range(0, tasks_val):\n if(max_time < tab[i]):\n max_time = tab[i]\n place = i\n tab[place] = 1\n tab1[iter] = place\n iter = iter + 1\n return tab1\n\n\ndef insertNEH(sequence, position, value):\n new_seq = sequence[:]\n new_seq.insert(position, value)\n return new_seq\n\n\ndef neh(tasks, machines_val, tasks_val):\n order = sum_and_order(tasks_val, machines_val, tasks)\n current_seq = [order[0]]\n for i in range(1, tasks_val):\n min_cmax = float(\"inf\")\n for j in range(0, i + 1):\n tmp = insertNEH(current_seq, j, order[i])\n cmax_tmp = makespan(tmp, tasks, machines_val)\n if min_cmax > cmax_tmp:\n best_seq = tmp\n min_cmax = cmax_tmp\n current_seq = best_seq\n return current_seq, makespan(current_seq, tasks, machines_val)\n\n\ndef read_data(filename):\n file = open(filename, \"r\")\n\n tasks_val, machines_val = file.readline().split()\n tasks_val = int(tasks_val)\n machines_val = int(machines_val)\n\n tasks = np.zeros((tasks_val,machines_val))\n for i in range(tasks_val):\n tmp = file.readline().split()\n for j in range(machines_val):\n tasks[i][j] = int(tmp[j*2+1])\n\n print(\"Number of tasks: \", tasks_val)\n print(\"Number of machines: \", machines_val)\n print(\"Tasks: \\n\", tasks)\n file.close()\n return tasks_val, machines_val, tasks\n\ndef read_ael_instances():\n tasks_val_list = [] \n machines_val_list = [] \n tasks_list = []\n\n for i in range(1,101):\n filename = \"ael_instances/\"+ str(i) + \".txt\"\n file = open(filename, \"r\")\n\n tasks_val, machines_val = file.readline().split()\n tasks_val = int(tasks_val)\n machines_val = int(machines_val)\n\n tasks = np.zeros((tasks_val,machines_val))\n for i in range(tasks_val):\n tmp = file.readline().split()\n for j in range(machines_val):\n tasks[i][j] = int(float(tmp[j*2+1]))\n\n tasks_val_list.append(tasks_val)\n machines_val_list.append(machines_val)\n tasks_list.append(tasks)\n\n file.close()\n\n return tasks_val_list, machines_val_list, tasks_list\n\n\nif __name__ == \"__main__\":\n #tasks_val, machines_val, tasks = read_data(\"data/small/VFR40_5_5_Gap.txt\")\n\n\n ##########\n # 1 - Annealing functions comparision\n # 2 - Number of operations comparision\n # 3 - Influence rejection the probability 1 on results\n # 4 - Influence rejection the probability when Cmax = CmaxOld\n # 5 - Influence Tstart and Tstop on results\n MODE = 1 # which mode should be executed\n ##########\n\n # T_start = 5000\n # T_end = 10\n iter_max = 1000\n \n best_cmaxs = []\n tasks_val, machines_val, tasks = read_ael_instances()\n\n for task_v, machine, task in zip(tasks_val, machines_val, tasks):\n #print(task_v, task, machine)\n #best_seq, best_cmax = sim_ann1(tasks_val, tasks, machines_val, 5000, 10)\n best_seq, best_cmax = ls(task_v, task, machine)\n #best_seq, best_cmax = sim_ann2(tasks_val, tasks, machines_val, T_start, T_end, iter_max) \n #print(\"normalized best Cmax: \", best_cmax)\n best_cmaxs.append(best_cmax)\n print(\"Average cmax = \",np.average(best_cmaxs))\n\n" }, { "path": "examples/user_fssp_gls/prob.py", "content": "import numpy as np\nimport importlib\nimport time\nfrom numba import jit\n\nimport random\nimport types\nimport warnings\nimport sys\n\nfrom numba.core.errors import NumbaDeprecationWarning, NumbaPendingDeprecationWarning\nimport warnings\n\nwarnings.simplefilter('ignore', category=NumbaDeprecationWarning)\nwarnings.simplefilter('ignore', category=NumbaPendingDeprecationWarning)\nwarnings.filterwarnings(\"ignore\", message=\"loaded more than 1 DLL from .libs\", category=UserWarning)\n\n@jit(nopython=True)\ndef makespan(order, tasks, machines_val):\n times = []\n for i in range(0, machines_val):\n times.append(0)\n for j in order:\n times[0] += tasks[j][0]\n for k in range(1, machines_val):\n if times[k] < times[k-1]:\n times[k] = times[k-1]\n times[k] += tasks[j][k]\n return max(times)\n\n\n@jit(nopython=True)\ndef local_search(sequence, cmax_old,tasks,machines_val):\n new_seq = sequence[:]\n for i in range(len(new_seq)):\n for j in range(i+1, len(new_seq)):\n temp_seq = new_seq[:]\n temp_seq[i], temp_seq[j] = temp_seq[j], temp_seq[i]\n cmax = makespan(temp_seq, tasks, machines_val)\n if cmax < cmax_old: # Assuming cmax_old is defined in sim_ann1 function\n new_seq = temp_seq[:]\n cmax_old = cmax\n #print(cmax)\n\n for i in range(1,len(new_seq)):\n for j in range(1,len(new_seq)):\n temp_seq = new_seq[:]\n temp_seq.remove(i)\n temp_seq.insert(j, i)\n cmax = makespan(temp_seq, tasks, machines_val)\n if cmax < cmax_old: # Assuming cmax_old is defined in sim_ann1 function\n new_seq = temp_seq[:]\n cmax_old = cmax\n #print(cmax)\n\n return new_seq\n\n@jit(nopython=True)\ndef local_search_perturb(sequence, cmax_old,tasks,machines_val,job):\n new_seq = sequence[:]\n for i in job:\n for j in range(i+1, len(new_seq)):\n temp_seq = new_seq[:]\n temp_seq[i], temp_seq[j] = temp_seq[j], temp_seq[i]\n cmax = makespan(temp_seq, tasks, machines_val)\n if cmax < cmax_old: # Assuming cmax_old is defined in sim_ann1 function\n new_seq = temp_seq[:]\n cmax_old = cmax\n #print(cmax)\n\n for i in job:\n for j in range(1,len(new_seq)):\n temp_seq = new_seq[:]\n temp_seq.remove(i)\n temp_seq.insert(j, i)\n cmax = makespan(temp_seq, tasks, machines_val)\n if cmax < cmax_old: # Assuming cmax_old is defined in sim_ann1 function\n new_seq = temp_seq[:]\n cmax_old = cmax\n #print(cmax)\n\n return new_seq\n\n\n\nclass JSSPGLS():\n def __init__(self) -> None:\n self.n_inst_eva = 3 # a small number of instances for test only\n self.iter_max = 1000 # number of iterations in GLS\n self.time_max = 30 # maximum time for each instance\n self.tasks_val, self.machines_val, self.tasks = self.read_instances()\n from prompts import GetPrompts\n self.prompts = GetPrompts()\n\n ############################################### Local Search ####################################################\n def ls(self,tasks_val, tasks, machines_val):\n pi0, cmax0 = self.neh(tasks, machines_val, tasks_val) \n #print(\"neh results: \",cmax0) \n pi = pi0\n cmax_old = cmax0\n while True:\n #piprim = local_search(pi, tasks_val)\n piprim = local_search(pi, cmax_old,tasks,machines_val)\n cmax = makespan(piprim, tasks, machines_val)\n if (cmax>=cmax_old):\n break\n else:\n pi = piprim\n cmax_old = cmax\n return pi, cmax_old\n\n ############################################### Iterated Local Search ####################################################\n def gls(self,heuristic):\n\n cmax_best_list = np.zeros(self.n_inst_eva)\n \n n_inst = 0\n for tasks_val,tasks,machines_val in zip(self.tasks_val, self.tasks, self.machines_val):\n \n cmax_best = 1E10\n random.seed(2024)\n #print(\"run ...\")\n try:\n pi, cmax = self.neh(tasks, machines_val, tasks_val) \n n = len(pi)\n \n pi_best = pi\n cmax_best = cmax\n n_itr = 0\n time_start = time.time()\n while time.time() - time_start < self.time_max and n_itr 5):\n jobs = jobs[:5]\n\n cmax = makespan(pi, tasks_perturb, machines_val)\n\n pi = local_search_perturb(pi, cmax,tasks_perturb,machines_val,jobs)\n\n n_itr +=1\n #print(f\"it {n_itr} , cmax {cmax_best}\")\n if n_itr % 50 == 0:\n pi = pi_best\n cmax = cmax_best\n\n except Exception as e:\n #print(\"Error:\", str(e)) # Print the error message\n cmax_best = 1E10\n \n #print(cmax_best)\n cmax_best_list[n_inst] = cmax_best\n n_inst += 1\n if n_inst == self.n_inst_eva:\n break\n \n return np.average(cmax_best_list)\n\n ###################################################################### NEH ############################################\n def sum_and_order(self,tasks_val, machines_val, tasks):\n tab = []\n tab1 = []\n for i in range(0, tasks_val):\n tab.append(0)\n tab1.append(0)\n for j in range(0, tasks_val):\n for k in range(0, machines_val):\n tab[j] += tasks[j][k]\n tmp_tab = tab.copy()\n place = 0\n iter = 0\n while(iter != tasks_val):\n max_time = 1\n for i in range(0, tasks_val):\n if(max_time < tab[i]):\n max_time = tab[i]\n place = i\n tab[place] = 1\n tab1[iter] = place\n iter = iter + 1\n return tab1\n\n\n def insertNEH(self,sequence, position, value):\n new_seq = sequence[:]\n new_seq.insert(position, value)\n return new_seq\n\n\n def neh(self,tasks, machines_val, tasks_val):\n order = self.sum_and_order(tasks_val, machines_val, tasks)\n current_seq = [order[0]]\n for i in range(1, tasks_val):\n min_cmax = float(\"inf\")\n for j in range(0, i + 1):\n tmp = self.insertNEH(current_seq, j, order[i])\n cmax_tmp = makespan(tmp, tasks, machines_val)\n if min_cmax > cmax_tmp:\n best_seq = tmp\n min_cmax = cmax_tmp\n current_seq = best_seq\n return current_seq, makespan(current_seq, tasks, machines_val)\n\n\n def read_instances(self):\n tasks_val_list = [] \n machines_val_list = [] \n tasks_list = []\n\n for i in range(1,65):\n filename = \"./TrainingData/\"+ str(i) + \".txt\"\n file = open(filename, \"r\")\n\n tasks_val, machines_val = file.readline().split()\n tasks_val = int(tasks_val)\n machines_val = int(machines_val)\n\n tasks = np.zeros((tasks_val,machines_val))\n for i in range(tasks_val):\n tmp = file.readline().split()\n for j in range(machines_val):\n tasks[i][j] = int(float(tmp[j*2+1]))\n\n tasks_val_list.append(tasks_val)\n machines_val_list.append(machines_val)\n tasks_list.append(tasks)\n\n file.close()\n\n return tasks_val_list, machines_val_list, tasks_list\n\n # def evaluate(self):\n # time.sleep(1)\n # try:\n # res = Parallel(n_jobs=4, timeout=self.time_max*1.1)(delayed(self.gls)(x, y, z, a) for x, y, z , a in zip(self.tasks_val, self.tasks, self.machines_val,[None]*len(self.tasks_val)))\n # #print(res)\n # #print(\"check\")\n # #print(\"Average cmax = \",np.mean(res))\n # return np.mean(res)\n # except Exception as e:\n # #print(\"Error:\",str(e))\n # return None\n\n \n def evaluate(self, code_string):\n try:\n # Suppress warnings\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n\n # Create a new module object\n heuristic_module = types.ModuleType(\"heuristic_module\")\n \n # Execute the code string in the new module's namespace\n exec(code_string, heuristic_module.__dict__)\n\n # Add the module to sys.modules so it can be imported\n sys.modules[heuristic_module.__name__] = heuristic_module\n\n #print(code_string)\n fitness = self.gls(heuristic_module)\n\n return fitness\n \n except Exception as e:\n #print(\"Error:\", str(e))\n return None\n\n\n \n\n" }, { "path": "examples/user_fssp_gls/prompts.py", "content": "\nclass GetPrompts():\n def __init__(self):\n self.prompt_task = \"I have n jobs and m machines. Help me create a novel algorithm to update the execution time matrix and select the top jobs to perturb to avoid being trapped in the local optimum scheduling \\\nwith the final goal of finding a scheduling with minimized makespan.\"\n self.prompt_func_name = \"get_matrix_and_jobs\"\n self.prompt_func_inputs = [\"current_sequence\",\"time_matrix\",\"m\",\"n\"]\n self.prompt_func_outputs = [\"new_matrix\",'perturb_jobs']\n self.prompt_inout_inf = \"The variable 'current_sequence' represents the current sequence of jobs. The variables 'm' and 'n' denote the number of machines and number of jobs, respectively. \\\nThe variable 'time_matrix' is a matrix of size n*m that contains the execution time of each job on each machine. The output 'new_matrix' is the updated time matrix, and 'perturb_jobs' includes the top jobs to be perturbed.\"\n self.prompt_other_inf = \"The matrix and job list are Numpy arrays.\"\n\n def get_task(self):\n return self.prompt_task\n \n def get_func_name(self):\n return self.prompt_func_name\n \n def get_func_inputs(self):\n return self.prompt_func_inputs\n \n def get_func_outputs(self):\n return self.prompt_func_outputs\n \n def get_inout_inf(self):\n return self.prompt_inout_inf\n\n def get_other_inf(self):\n return self.prompt_other_inf\n\nif __name__ == \"__main__\":\n getprompts = GetPrompts()\n print(getprompts.get_task())\n" }, { "path": "examples/user_fssp_gls/runEoH.py", "content": "from eoh import eoh\nfrom eoh.utils.getParas import Paras\nfrom prob import JSSPGLS\n\n# Parameter initilization #\nparas = Paras() \n\n# Set your local problem\nproblem_local = JSSPGLS()\n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = problem_local, # Set local problem, else use default problems\n llm_api_endpoint = \"XXX\", # set your LLM endpoint\n llm_api_key = \"XXX\", # set your key\n llm_model = \"gpt-3.5-turbo\",\n ec_pop_size = 4, # number of samples in each population\n ec_n_pop = 4, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False,\n eva_numba_decorator = False,\n eva_timeout = 120 \n # Set the maximum evaluation time for each heuristic !\n # increase it if more instances are used for evaluation !\n ) \n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()" }, { "path": "examples/user_tsp_gls/TestingData/check_instance.py", "content": "import pickle as pkl\nimport random\n\ninstances_path = 'TSP100.pkl'\noutput_path = 'random_instances.pkl'\n\n# Open the pickle file in read mode\nwith open(instances_path, 'rb') as file:\n # Load the data from the pickle file\n data = pkl.load(file)\n\n# Access the individual data elements\ncoords = data['coordinate']\noptimal_tour = data['optimal_tour']\ninstances = data['distance_matrix']\nopt_costs = data['cost']\n\n# Randomly select 64 instances\nrandom_instances = random.sample(range(len(opt_costs)), 64)\n\n# Filter the data based on the selected instances\nselected_coords = [coords[i] for i in random_instances]\nselected_optimal_tour = [optimal_tour[i] for i in random_instances]\nselected_instances = [instances[i] for i in random_instances]\nselected_opt_costs = [opt_costs[i] for i in random_instances]\n\n# Create a new data dictionary with the selected instances\nselected_data = {\n 'coordinate': selected_coords,\n 'optimal_tour': selected_optimal_tour,\n 'distance_matrix': selected_instances,\n 'cost': selected_opt_costs\n}\n\n# Write the selected data to a new pickle file\nwith open(output_path, 'wb') as file:\n pkl.dump(selected_data, file)\n" }, { "path": "examples/user_tsp_gls/gls/gls_evol.py", "content": "import time\nimport numpy as np\nfrom numba import jit\nfrom gls import gls_operators\nfrom utils import utils\nimport random\n\n#@jit(nopython=True) \ndef nearest_neighbor(dis_matrix, depot):\n tour = [depot]\n n = len(dis_matrix)\n nodes = np.arange(n)\n while len(tour) < n:\n i = tour[-1]\n neighbours = [(j, dis_matrix[i,j]) for j in nodes if j not in tour]\n j, dist = min(neighbours, key=lambda e: e[1])\n tour.append(j)\n\n tour.append(depot)\n\n return tour\n\n#@jit(nopython=True) \ndef nearest_neighbor_2End(dis_matrix, depot):\n tour = [depot]\n n = len(dis_matrix)\n nodes = np.arange(n)\n while len(tour) < n:\n i = tour[-1]\n neighbours = [(j, dis_matrix[i,j]) for j in nodes if j not in tour]\n j, dist = min(neighbours, key=lambda e: e[1])\n tour.append(j)\n\n tour.append(depot)\n route2End = np.zeros((n,2))\n route2End[0,0] = tour[-2]\n route2End[0,1] = tour[1]\n for i in range(1,n):\n route2End[tour[i],0] = tour[i-1]\n route2End[tour[i],1] = tour[i+1]\n return route2End\n\n\n@jit(nopython=True) \ndef local_search(init_tour, init_cost, D, N, first_improvement=False):\n cur_route, cur_cost = init_tour, init_cost\n # search_progress = []\n\n improved = True\n while improved:\n\n improved = False\n # for operator in [operators.two_opt_a2a, operators.relocate_a2a]:\n\n delta, new_tour = gls_operators.two_opt_a2a(cur_route, D,N, first_improvement)\n if delta < 0:\n improved = True\n cur_cost += delta\n cur_route = new_tour\n\n # search_progress.append({\n # 'time': time.time(),\n # 'cost': cur_cost\n # })\n\n delta, new_tour = gls_operators.relocate_a2a(cur_route, D,N, first_improvement)\n if delta < 0:\n improved = True\n cur_cost += delta\n cur_route = new_tour\n\n # search_progress.append({\n # 'time': time.time(),\n # 'cost': cur_cost\n # }) \n\n return cur_route, cur_cost\n\n@jit(nopython=True) \ndef route2tour(route):\n s = 0\n tour=[]\n for i in range(len(route)):\n tour.append(route[s,1])\n s = route[s,1] \n return tour\n\n@jit(nopython=True) \ndef tour2route(tour):\n n = len(tour)\n route2End = np.zeros((n,2))\n route2End[tour[0],0] = tour[-1]\n route2End[tour[0],1] = tour[1]\n for i in range(1,n-1):\n route2End[tour[i],0] = tour[i-1]\n route2End[tour[i],1] = tour[i+1] \n route2End[tour[n-1],0] = tour[n-2]\n route2End[tour[n-1],1] = tour[0]\n return route2End\n\n\n\n# @jit(nopython=True) \ndef guided_local_search(coords, edge_weight, nearest_indices, init_tour, init_cost, t_lim,ite_max, perturbation_moves,\n first_improvement=False,guide_algorithm=None):\n\n # Set a random seed\n random.seed(2024)\n\n cur_route, cur_cost = local_search(init_tour, init_cost, edge_weight,nearest_indices, first_improvement)\n best_route, best_cost = cur_route, cur_cost\n\n\n length = len(edge_weight[0])\n\n n_pert = min(int(length/10),20)\n\n iter_i = 0\n\n edge_penalty = np.zeros((length,length))\n\n while iter_i < ite_max and time.time() 0 and i < len(tour) - 1\n\n best_move = None\n best_delta = 0\n\n idxs = range(1, len(tour) - 1)\n for j in idxs:\n if abs(i - j) < 2:\n continue\n\n delta = two_opt_cost(tour, D, i, j)\n if delta < best_delta and not np.isclose(0, delta):\n best_delta = delta\n best_move = i, j\n if first_improvement:\n break\n\n if best_move is not None:\n return best_delta, two_opt(tour, *best_move)\n return 0, tour\n\n@jit(nopython=True)\ndef two_opt_o2a_all(tour, D,N, i):\n\n best_move = None\n best_delta = 0\n\n idxs = N[i]\n for j in idxs:\n if i in tour[j] or j in tour[i]:\n continue\n delta = two_opt_cost(tour, D, i, j)\n if delta < best_delta and not np.isclose(0, delta):\n best_delta = delta\n best_move = i, j\n tour = two_opt(tour, *best_move)\n\n return best_delta , tour\n\n\n@jit(nopython=True)\ndef relocate(tour, i, j):\n a = tour[i,0]\n b = tour[i,1]\n tour[a,1] = b\n tour[b,0] = a\n\n d = tour[j,1]\n tour[d,0] = i\n tour[i,0] = j\n tour[i,1] = d\n tour[j,1] = i\n\n return tour\n\n@jit(nopython=True)\ndef relocate_cost(tour, D, i, j):\n if i == j:\n return 0\n\n a = tour[i,0]\n b = i\n c = tour[i,1]\n\n d = j\n e = tour[j,1]\n\n delta = - D[a, b] \\\n - D[b, c] \\\n + D[a, c] \\\n - D[d, e] \\\n + D[d, b] \\\n + D[b, e]\n return delta\n\n@jit(nopython=True)\ndef relocate_o2a(tour, D, i, first_improvement=False):\n assert i > 0 and i < len(tour) - 1\n\n best_move = None\n best_delta = 0\n\n idxs = range(1, len(tour) - 1)\n for j in idxs:\n if i == j:\n continue\n\n delta = relocate_cost(tour, D, i, j)\n if delta < best_delta and not np.isclose(0, delta):\n best_delta = delta\n best_move = i, j\n if first_improvement:\n break\n\n if best_move is not None:\n return best_delta, relocate(tour, *best_move)\n return 0, tour\n\n@jit(nopython=True)\ndef relocate_o2a_all(tour, D,N, i):\n best_move = None\n best_delta = 0\n\n for j in N[i]:\n if tour[j,1] == i: # e.g. relocate 2 -> 3 == relocate 3 -> 2\n continue\n\n delta = relocate_cost(tour, D, i, j)\n if delta < best_delta and not np.isclose(0, delta):\n best_delta = delta\n best_move = i, j\n tour = relocate(tour, *best_move)\n\n return best_delta, tour\n\n@jit(nopython=True)\ndef relocate_a2a(tour, D,N, first_improvement=False, set_delta=0):\n best_move = None\n best_delta = set_delta\n\n idxs = range(0, len(tour) - 1)\n for i in idxs:\n for j in N[i]:\n if tour[j,1] == i: # e.g. relocate 2 -> 3 == relocate 3 -> 2\n continue\n\n delta = relocate_cost(tour, D, i, j)\n if delta < best_delta and not np.isclose(0, delta):\n best_delta = delta\n best_move = i, j\n if first_improvement:\n break\n\n if best_move is not None:\n return best_delta, relocate(tour, *best_move)\n return 0, tour\n" }, { "path": "examples/user_tsp_gls/gls/gls_run.py", "content": "\nimport time\nimport importlib\nimport numpy as np\n\nfrom utils import utils\nfrom gls import gls_evol\n\ndef solve_instance(n,opt_cost,dis_matrix,coord,time_limit, ite_max, perturbation_moves,heuristic):\n\n # time_limit = 60 # maximum 10 seconds for each instance\n # ite_max = 1000 # maximum number of local searchs in GLS for each instance\n # perturbation_moves = 1 # movers of each edge in each perturbation\n\n \n time.sleep(1)\n t = time.time()\n\n try:\n init_tour = gls_evol.nearest_neighbor_2End(dis_matrix, 0).astype(int)\n init_cost = utils.tour_cost_2End(dis_matrix, init_tour)\n nb = 100\n nearest_indices = np.argsort(dis_matrix, axis=1)[:, 1:nb+1].astype(int)\n\n best_tour, best_cost, iter_i = gls_evol.guided_local_search(coord, dis_matrix, nearest_indices, init_tour, init_cost,\n t + time_limit, ite_max, perturbation_moves,\n first_improvement=False, guide_algorithm=heuristic)\n\n gap = (best_cost / opt_cost - 1) * 100\n\n except Exception as e:\n #print(\"Error:\", str(e)) # Print the error message\n gap = 1E10\n \n #print(f\"instance {n+1}: cost = {best_cost:.3f}, gap = {gap:.3f}, n_it = {iter_i}, cost_t = {time.time()-t:.3f}\")\n\n return gap" }, { "path": "examples/user_tsp_gls/gls/gls_test.py", "content": "import time\n\nimport networkx as nx\nimport numpy as np\nfrom numba import jit\nfrom ael import alg\nfrom utils import utils\nfrom . import operators\nimport random\n\n#@jit(nopython=True) \ndef nearest_neighbor_2End(dis_matrix, depot):\n tour = [depot]\n n = len(dis_matrix)\n nodes = np.arange(n)\n while len(tour) < n:\n i = tour[-1]\n neighbours = [(j, dis_matrix[i,j]) for j in nodes if j not in tour]\n j, dist = min(neighbours, key=lambda e: e[1])\n tour.append(j)\n\n tour.append(depot)\n route2End = np.zeros((n,2))\n route2End[0,0] = tour[-2]\n route2End[0,1] = tour[1]\n for i in range(1,n):\n route2End[tour[i],0] = tour[i-1]\n route2End[tour[i],1] = tour[i+1]\n return route2End\n\n@jit(nopython=True) \ndef local_search(init_tour, init_cost, D,N, first_improvement=False):\n cur_route, cur_cost = init_tour, init_cost\n # search_progress = []\n\n improved = True\n n = 0\n\n # print(cur_route)\n # input()\n while improved:\n\n improved = False\n # for operator in [operators.two_opt_a2a, operators.relocate_a2a]:\n\n delta, new_tour = operators.two_opt_a2a(cur_route, D,N, first_improvement)\n if delta < 0:\n improved = True\n cur_cost += delta\n cur_route = new_tour\n\n # search_progress.append({\n # 'time': time.time(),\n # 'cost': cur_cost\n # })\n # print(delta)\n\n\n delta, new_tour = operators.relocate_a2a(cur_route, D,N, first_improvement)\n if delta < 0:\n improved = True\n cur_cost += delta\n cur_route = new_tour\n\n # search_progress.append({\n # 'time': time.time(),\n # 'cost': cur_cost\n # }) \n # print(delta)\n # print(cur_route)\n # input()\n\n n += 1\n return cur_route, cur_cost\n\n@jit(nopython=True)\ndef calculate_width(depot , center_of_gravity, node_i, node_j):\n\n # Calculate the perpendicular axis (axis connecting the depot and center of gravity)\n depot_x, depot_y = depot[0],depot[1]\n gravity_x, gravity_y = center_of_gravity[0],center_of_gravity[1]\n\n perpendicular_axis_x = depot_y - gravity_y\n perpendicular_axis_y = gravity_x - depot_x\n\n # Calculate the distance between nodes i and j along the perpendicular axis\n distance = abs((node_i[0] - node_j[0]) * perpendicular_axis_x + (node_i[1] - node_j[1]) * perpendicular_axis_y)\n\n return distance\n@jit(nopython=True)\ndef find_indices(Route):\n Route = Route[:-1]\n n = len(Route)\n indices = []\n\n # Iterate over the range of IDs\n for i in range(n):\n index = Route.index(i)\n indices.append(index)\n\n\n return indices\n\n@jit(nopython=True) \ndef route2tour(route):\n s = 0\n tour=[]\n for i in range(len(route)):\n tour.append(route[s,1])\n s = route[s,1] \n return tour\n\n@jit(nopython=True) \ndef tour2route(tour):\n n = len(tour)\n route2End = np.zeros((n,2))\n route2End[tour[0],0] = tour[-1]\n route2End[tour[0],1] = tour[1]\n for i in range(1,n-1):\n route2End[tour[i],0] = tour[i-1]\n route2End[tour[i],1] = tour[i+1] \n route2End[tour[n-1],0] = tour[n-2]\n route2End[tour[n-1],1] = tour[0]\n return route2End\n\n\n#@jit(nopython=True)\ndef guided_local_search(coords, edge_weight, nearest_indices, init_tour, init_cost, t_lim,iter_max, perturbation_moves,\n first_improvement,algorithm):\n \n\n cur_route, cur_cost = local_search(init_tour, init_cost, edge_weight,nearest_indices, first_improvement)\n best_route, best_cost = cur_route, cur_cost\n\n cur_route_local = cur_route\n\n length = len(edge_weight[0])\n\n if algorithm in [\"LS\"]:\n pass\n elif algorithm in [\"KGLS_c\",\"KGLS_r\"]:\n\n center = np.mean(coords,axis=1)\n # center[0] = np.mean(coords[0,:])\n # center[1] = np.mean(coords[1,:])\n\n perturbation_moves = 10 # set the defaul for KGLS\n \n k = 0.1 * cur_cost / length # initialize k according to \n\n iter_i = 0\n edge_penalty = np.zeros((length,length))\n\n while iter_i max_util or max_util_e is None:\n max_util = util\n max_util_e = e\n elif algorithm == \"KGLS_r\" and iter_i%3 == 1:\n # penalize edge\n max_util = 0\n max_util_e = None\n for e in zip(cur_route[:-1], cur_route[1:]):\n width = calculate_width(coords[0],center,coords[e[0]],coords[e[1]])\n util = (width + edge_weight[e[0],e[1]]) / (1 + edge_penalty[e[0],e[1]])\n if util > max_util or max_util_e is None:\n max_util = util\n max_util_e = e\n else:\n # penalize edge\n max_util = 0\n max_util_e = None\n for e in zip(cur_route[:-1], cur_route[1:]):\n util = edge_weight[e[0],e[1]] / (1 + edge_penalty[e[0],e[1]])\n if util > max_util or max_util_e is None:\n max_util = util\n max_util_e = e \n \n\n edge_penalty[max_util_e[0],max_util_e[1]] += 1.\n edge_penalty[max_util_e[1],max_util_e[0]] += 1.\n\n edge_weight_guided = edge_weight + k * edge_penalty\n\n # apply operator to edge\n for n in max_util_e:\n if n != 0: # not the depot\n i = cur_route.index(n)\n\n for operator in [operators.two_opt_o2a, operators.relocate_o2a]:\n moved = False\n\n delta, new_tour = operator(cur_route, edge_weight_guided, i, first_improvement)\n if delta < 0:\n cur_cost = utils.tour_cost_2End(edge_weight, new_tour)\n cur_route = new_tour\n moved = True\n\n moves += moved\n\n # optimisation\n cur_route, cur_cost = local_search(cur_route, cur_cost, edge_weight, first_improvement)\n cur_route_local = cur_route\n \n # search_progress += new_search_progress\n if cur_cost < best_cost:\n best_route, best_cost = cur_route, cur_cost\n #print(str(iter_i)+\" current cost = \",cur_cost)\n iter_i += 1\n\n elif algorithm in ['GLS','EBGLS']:\n \n if algorithm == 'GLS':\n k = 0.1 * cur_cost / length # initialize k according to \n elif algorithm == 'EBGLS':\n k = 0.3 * cur_cost / length # initialize k according to \n w = 2\n tour_e = cur_route\n\n iter_i = 0\n edge_penalty = np.zeros((length,length))\n\n while iter_i t_lim/10:\n for e in zip(np.arange(length), cur_route[:,1]):\n if e in tour_e:\n util = edge_weight[e[0],e[1]] / (1 + edge_penalty[e[0],e[1]])\n else:\n util = w*edge_weight[e[0],e[1]] / (1 + edge_penalty[e[0],e[1]])\n if util > max_util or max_util_e is None:\n max_util = util\n max_util_e = e\n elif algorithm == 'GLS':\n for e in zip(np.arange(length), cur_route[:,1]):\n util = edge_weight[e[0],e[1]] / (1 + edge_penalty[e[0],e[1]])\n if util > max_util or max_util_e is None:\n max_util = util\n max_util_e = e\n\n edge_penalty[max_util_e[0],max_util_e[1]] += 1.\n edge_penalty[max_util_e[1],max_util_e[0]] += 1.\n\n edge_weight_guided = edge_weight + k * edge_penalty\n\n # optimisation\n cur_route, cur_cost = local_search(cur_route, cur_cost, edge_weight_guided, first_improvement)\n\n cur_cost = utils.tour_cost_2End(edge_weight, cur_route)\n\n # search_progress += new_search_progress\n if cur_cost < best_cost:\n best_route, best_cost = cur_route, cur_cost\n print(str(iter_i)+\" current cost = \",cur_cost)\n iter_i += 1\n\n if algorithm == \"EBGLS\" and iter_i % 50 == 0:\n tour_e = zip(best_route[:-1], best_route[1:])\n\n\n elif algorithm == \"AELGLS\":\n iter_i = 0\n edge_penalty = np.zeros((length,length))\n\n ruin_max = max(int(length/10),20)\n ruin_min = min(int(length/10),20)\n while iter_i < iter_max and time.time()best_cost*1.01:\n cur_route = best_route\n\n else:\n\n print(f\"the algorithm {algorithm} is not implemented !\")\n\n return best_route, best_cost\n" }, { "path": "examples/user_tsp_gls/prob.py", "content": "import numpy as np\nimport time\nfrom joblib import Parallel, delayed\nimport os\nimport types\nimport warnings\nimport sys\n\nfrom utils import readTSPRandom\nfrom gls.gls_run import solve_instance\n\nclass TSPGLS():\n def __init__(self) -> None:\n self.n_inst_eva = 3 # a samll value for test only\n self.time_limit = 10 # maximum 10 seconds for each instance\n self.ite_max = 1000 # maximum number of local searchs in GLS for each instance\n self.perturbation_moves = 1 # movers of each edge in each perturbation\n path = os.path.dirname(os.path.abspath(__file__))\n self.instance_path = path+'/TrainingData/TSPAEL64.pkl' #,instances=None,instances_name=None,instances_scale=None\n self.debug_mode=False\n\n self.coords,self.instances,self.opt_costs = readTSPRandom.read_instance_all(self.instance_path)\n\n from prompts import GetPrompts\n self.prompts = GetPrompts()\n\n\n def tour_cost(self,instance, solution, problem_size):\n cost = 0\n for j in range(problem_size - 1):\n cost += np.linalg.norm(instance[int(solution[j])] - instance[int(solution[j + 1])])\n cost += np.linalg.norm(instance[int(solution[-1])] - instance[int(solution[0])])\n return cost\n\n def generate_neighborhood_matrix(self,instance):\n instance = np.array(instance)\n n = len(instance)\n neighborhood_matrix = np.zeros((n, n), dtype=int)\n\n for i in range(n):\n distances = np.linalg.norm(instance[i] - instance, axis=1)\n sorted_indices = np.argsort(distances) # sort indices based on distances\n neighborhood_matrix[i] = sorted_indices\n\n return neighborhood_matrix\n\n def evaluateGLS(self,heuristic):\n\n gaps = np.zeros(self.n_inst_eva)\n\n for i in range(self.n_inst_eva):\n gap = solve_instance(i,self.opt_costs[i], \n self.instances[i], \n self.coords[i],\n self.time_limit,\n self.ite_max,\n self.perturbation_moves,\n heuristic)\n gaps[i] = gap\n\n return np.mean(gaps)\n \n\n def evaluate(self, code_string):\n try:\n # Suppress warnings\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n\n # Create a new module object\n heuristic_module = types.ModuleType(\"heuristic_module\")\n \n # Execute the code string in the new module's namespace\n exec(code_string, heuristic_module.__dict__)\n\n # Add the module to sys.modules so it can be imported\n sys.modules[heuristic_module.__name__] = heuristic_module\n\n #print(code_string)\n fitness = self.evaluateGLS(heuristic_module)\n\n return fitness\n \n except Exception as e:\n #print(\"Error:\", str(e))\n return None\n\n\n\n" }, { "path": "examples/user_tsp_gls/prompts.py", "content": "class GetPrompts():\n def __init__(self):\n self.prompt_task = \"Task: Given an edge distance matrix and a local optimal route, please help me design a strategy to update the distance matrix to avoid being trapped in the local optimum with the final goal of finding a tour with minimized distance. \\\nYou should create a heuristic for me to update the edge distance matrix.\"\n self.prompt_func_name = \"update_edge_distance\"\n self.prompt_func_inputs = ['edge_distance', 'local_opt_tour', 'edge_n_used']\n self.prompt_func_outputs = ['updated_edge_distance']\n self.prompt_inout_inf = \"'local_opt_tour' includes the local optimal tour of IDs, 'edge_distance' and 'edge_n_used' are matrixes, 'edge_n_used' includes the number of each edge used during permutation.\"\n self.prompt_other_inf = \"All are Numpy arrays.\"\n\n def get_task(self):\n return self.prompt_task\n \n def get_func_name(self):\n return self.prompt_func_name\n \n def get_func_inputs(self):\n return self.prompt_func_inputs\n \n def get_func_outputs(self):\n return self.prompt_func_outputs\n \n def get_inout_inf(self):\n return self.prompt_inout_inf\n\n def get_other_inf(self):\n return self.prompt_other_inf\n \n# def get_prompt_create(self):\n# prompt_content = \"Task: Given an edge distance matrix and a local optimal route, please help me design a strategy to update the distance matrix to avoid being trapped in the local optimum with the final goal of finding a tour with minimized distance. \\\n# You should create a strategy for me to update the edge distance matrix. \\\n# Provide a description of the new strategy in no more than two sentences. The description must be inside a brace. \\\n# Provide the Python code for the new strategy. The code is a Python function called 'update_edge_distance' that takes three inputs 'edge_distance', 'local_opt_tour', 'edge_n_used', and outputs the 'updated_edge_distance', \\\n# where 'local_opt_tour' includes the local optimal tour of IDs, 'edge_distance' and 'edge_n_used' are matrixes, 'edge_n_used' includes the number of each edge used during permutation. All are Numpy arrays. Pay attention to the format and do not give additional explanation.\"\n# return prompt_content\n \n\n# def get_prompt_crossover(self,indiv1,indiv2):\n# prompt_content = \"Task: Given an edge distance matrix and a local optimal route, please help me design a strategy to update the distance matrix to avoid being trapped in the local optimum with the final goal of finding a tour with minimized distance. \\\n# I have two strategies with their codes to update the distance matrix. \\\n# The first strategy and the corresponding code are: \\n\\\n# Strategy description: \"+indiv1['algorithm']+\"\\n\\\n# Code:\\n\\\n# \"+indiv1['code']+\"\\n\\\n# The second strategy and the corresponding code are: \\n\\\n# Strategy description: \"+indiv2['algorithm']+\"\\n\\\n# Code:\\n\\\n# \"+indiv2['code']+\"\\n\\\n# Please help me create a new strategy that is totally different from them but can be motivated from them. \\\n# Provide a description of the new strategy in no more than two sentences. The description must be inside a brace. \\\n# Provide the Python code for the new strategy. The code is a Python function called 'update_edge_distance' that takes three inputs 'edge_distance', 'local_opt_tour', 'edge_n_used', and outputs the 'updated_edge_distance', \\\n# where 'local_opt_tour' includes the local optimal tour of IDs, 'edge_distance' and 'edge_n_used' are matrixes, 'edge_n_used' includes the number of each edge used during permutation. All are Numpy arrays. Pay attention to the format and do not give additional explanation.\"\n# return prompt_content\n \n# def get_prompt_mutation(self,indiv1):\n# prompt_content = \"Task: Given a set of nodes with their coordinates, \\\n# you need to find the shortest route that visits each node once and returns to the starting node. \\\n# The task can be solved step-by-step by starting from the current node and iteratively choosing the next node. \\\n# I have a strategy with its code to select the next node in each step as follows. \\\n# Strategy description: \"+indiv1['algorithm']+\"\\n\\\n# Code:\\n\\\n# \"+indiv1['code']+\"\\n\\\n# Please assist me in creating a modified version of the strategy provided. \\\n# Provide a description of the new strategy in no more than two sentences. The description must be inside a brace. \\\n# Provide the Python code for the new strategy. The code is a Python function called 'update_edge_distance' that takes three inputs 'edge_distance', 'local_opt_tour', 'edge_n_used', and outputs the 'updated_edge_distance', \\\n# where 'local_opt_tour' includes the local optimal tour of IDs, 'edge_distance' and 'edge_n_used' are matrixes, 'edge_n_used' includes the number of each edge used during permutation. All are Numpy arrays. Pay attention to the format and do not give additional explanation.\"\n# return prompt_content\n" }, { "path": "examples/user_tsp_gls/runEoH.py", "content": "from eoh import eoh\nfrom eoh.utils.getParas import Paras\nfrom prob import TSPGLS\n\n# Parameter initilization #\nparas = Paras() \n\n# Set your local problem\nproblem_local = TSPGLS()\n\n# Set parameters #\nparas.set_paras(method = \"eoh\", # ['ael','eoh']\n problem = problem_local, # Set local problem, else use default problems\n llm_api_endpoint = \"XXX\", # set your LLM endpoint\n llm_api_key = \"XXX\", # set your key\n llm_model = \"gpt-3.5-turbo\",\n ec_pop_size = 4, # number of samples in each population\n ec_n_pop = 4, # number of populations\n exp_n_proc = 4, # multi-core parallel\n exp_debug_mode = False,\n eva_numba_decorator = False,\n eva_timeout = 60 \n # Set the maximum evaluation time for each heuristic !\n # Increase it if more instances are used for evaluation !\n ) \n\n# initilization\nevolution = eoh.EVOL(paras)\n\n# run \nevolution.run()" }, { "path": "examples/user_tsp_gls/utils/readTSPLib.py", "content": "import numpy as np\nimport networkx as nx\n# Read coordinates from input file\nfrom numba import jit\nimport os\n\n#@jit(nopython=True) \ndef read_coordinates(file_name):\n coordinates = []\n file = open(file_name, 'r')\n lines = file.readlines()\n for line in lines:\n if line.startswith('NODE_COORD_SECTION'):\n index = lines.index(line) + 1\n break\n for i in range(index, len(lines)-1):\n parts = lines[i].split()\n if (parts[0]=='EOF'): break\n coordinates.append((int(parts[0]), float(parts[1]), float(parts[2])))\n return coordinates\n\n#@jit(nopython=True) \ndef create_distance_matrix(coordinates):\n\n x = np.array([coord[1] for coord in coordinates])\n y = np.array([coord[2] for coord in coordinates])\n\n min = np.min(coordinates)\n max = np.max(coordinates)\n\n x_normalized = (x - min) / (max - min)\n y_normalized = (y - min) / (max - min)\n\n x_diff = np.subtract.outer(x_normalized, x_normalized)\n y_diff = np.subtract.outer(y_normalized, y_normalized)\n distance_matrix = np.sqrt(x_diff**2 + y_diff**2)\n return distance_matrix, max - min\n\n#@jit(nopython=True) \ndef transform_to_graph(distance_matrix):\n num_nodes = distance_matrix.shape[0]\n\n graph = nx.Graph()\n\n for i in range(num_nodes):\n graph.add_node(i)\n\n for i in range(num_nodes):\n for j in range(i, num_nodes):\n graph.add_edge(i, j, weight=distance_matrix[i, j], weight_name='weight')\n graph.add_edge(j, i, weight=distance_matrix[i, j], weight_name='weight')\n\n return graph\n\n#@jit(nopython=True) \ndef read_instance(filename):\n\n # Test the code\n coordinates = read_coordinates(filename)\n distance_matrix, scale = create_distance_matrix(coordinates)\n G = transform_to_graph(distance_matrix)\n\n # return distance matrix\n return G, scale\n\ndef read_instance_all(instances_path):\n instances = []\n instances_scale = []\n instances_name = []\n file_names = os.listdir(instances_path)\n for filename in file_names:\n G,scale = read_instance(instances_path +\"/\"+ filename)\n instances.append(G)\n instances_scale.append(scale)\n instances_name.append(filename)\n return instances,instances_scale,instances_name\n\n\n\nif __name__ == '__main__':\n G,scale= read_instance_all('../TSPLib200/eil51.tsp')\n print(G.edges[0,0]['weight'])\n print(scale)" }, { "path": "examples/user_tsp_gls/utils/readTSPRandom.py", "content": "\nimport pickle as pkl\n\ndef read_instance_all(instances_path):\n\n # Open the pickle file in read mode\n with open(instances_path, 'rb') as file:\n # Load the data from the pickle file\n data = pkl.load(file)\n\n # Access the individual data elements\n coords = data['coordinate']\n optimal_tour = data['optimal_tour']\n instances = data['distance_matrix']\n opt_costs = data['cost']\n \n return coords,instances,opt_costs\n\n" }, { "path": "examples/user_tsp_gls/utils/utils.py", "content": "\nfrom numba import jit\n\ndef tour_to_edge_attribute(G, tour):\n in_tour = {}\n tour_edges = list(zip(tour[:-1], tour[1:]))\n for e in G.edges:\n in_tour[e] = e in tour_edges or tuple(reversed(e)) in tour_edges\n return in_tour\n\n#@jit(nopython=True)\ndef tour_cost(dis_m, tour):\n c = 0\n for e in zip(tour[:-1], tour[1:]):\n c += dis_m[e]\n return c\n\n@jit(nopython=True)\ndef tour_cost_2End(dis_m, tour2End):\n c=0\n s = 0\n e = tour2End[0,1]\n for i in range(tour2End.shape[0]):\n c += dis_m[s,e]\n s = e\n e = tour2End[s,1]\n return c\n\n\ndef is_equivalent_tour(tour_a, tour_b):\n if tour_a == tour_b[::-1]:\n return True\n if tour_a == tour_b:\n return True\n return False\n" }, { "path": "version_log.txt", "content": "\n\t" } ]